187594 2014-03-14 20:50:00 +0000 [zfs] [patch] ZFS ARC behavior problem and fix 2019-07-29 17:45:26 +0000 1 1 1 Unclassified Base System kern 10.0-STABLE Any Any Closed FIXED Normal Affects Some People --- 1 karl smh 214748mv ACCOUNT_DELETED FreeBSD Mark.Martinec+freebsd Mark.Martinec adrian allanjude avg bdrewery chris crest cy dch dpetrov67 emaste feld fk fullermd gibbs ian jhay jhb junchoon karl ktk mikej mmoll o.hushchenkov ota pi rainer rynunes seanc seanc sef sigsys smh swills tablosazi.farahan thierry thomasrcurry vanheugten vhaisman vsasjason vsjcfm will xistence oldest_to_newest 755203 0 karl 2014-03-14 20:50:00 +0000 ZFS can be convinced to engage in pathological behavior due to a bad low-memory test in arc.c The offending file is at /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c; it allegedly checks for 25% free memory, and if it is less asks for the cache to shrink. (snippet from arc.c around line 2494 of arc.c in 10-STABLE; path /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs) #else /* !sun */ if (kmem_used() > (kmem_size() * 3) / 4) return (1); #endif /* sun */ Unfortunately these two functions do not return what the authors thought they did. It's clear what they're trying to do from the Solaris-specific code up above this test. The result is that the cache only shrinks when vm_paging_needed() tests true, but by that time the system is in serious memory trouble and by triggering only there it actually drives the system further into paging, because the pager will not recall pages from the swap until they are next executed. This leads the ARC to try to fill in all the available RAM even though pages have been pushed off onto swap. Not good. Fix: The following context diff corrects the problem. If NEWRECLAIM is defined (by default turned on once the patch is applied) we declare and export a new tunable: vfs.zfs.arc_freepage_percent_target The default on zfs load is set to to 25 percent, as was the intent of the original software. You may tune this in real time with sysctl to suit your workload and machine's installed RAM; unlike setting "arc_max" which can only be done at boot the target RAM consumption percentage is adaptive. Instead of the above code we then test for wired, active, inactive and cache pages, comparing free space against the total. If the free space is less in percentage terms than the sum of all five we declare memory constrained, otherwise we declare that it is not. We retain the paging check but none of the others if this option is declared. A debugging flag called "NEWRECLAIM_DEBUG" is present in the code, if changed from "undef" to "define" at compile time it will cause printing of status changes (constrained .vs. not) along with any picked up changes in the target in real-time. This should not be used in production. How-To-Repeat: Set up a cache-heavy workload on large (~terabyte sized or bigger) ZFS filesystems and note that free RAM drops to the point that starvation occurs, while "wired" memory pins at the maximum ARC cache size, even though you have other demands for RAM that should cause the ARC memory congestion control algorithm to evict some of the cache as demand rises. It does not. 755204 1 linimon 2014-03-15 21:21:18 +0000 Responsible Changed From-To: freebsd-bugs->freebsd-fs Over to maintainer(s). 755205 2 ebay 2014-03-16 03:42:00 +0000 This is generally working well for me so far, been running it over a day on my desktop at home with only 4G ram and I have not needlessly swapped. Generally have 1GB or more free ram now although I also decreased vfs.zfs.arc_freepage_percent_target to 15 because my ARC total was pretty low. At the moment I have 406M ARC and 1070M free while Thunderbird and over a dozen Chromium tabs open. Thanks for working on a patch! 755206 3 avg 2014-03-18 15:15:05 +0000 Karl Denninger <karl@fs.denninger.net> wrote: > ZFS can be convinced to engage in pathological behavior due to a bad > low-memory test in arc.c > > The offending file is at > /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c; it allegedly > checks for 25% free memory, and if it is less asks for the cache to shrink. > > (snippet from arc.c around line 2494 of arc.c in 10-STABLE; path > /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs) > > #else /* !sun */ > if (kmem_used() > (kmem_size() * 3) / 4) > return (1); > #endif /* sun */ > > Unfortunately these two functions do not return what the authors thought > they did. It's clear what they're trying to do from the Solaris-specific > code up above this test. No, these functions do return what the authors think they do. The check is for KVA usage (kernel virtual address space), not for physical memory. > The result is that the cache only shrinks when vm_paging_needed() tests > true, but by that time the system is in serious memory trouble and by No, it is not. The description and numbers here are a little bit outdated but they should give an idea of how paging works in general: https://wiki.freebsd.org/AvgPageoutAlgorithm > triggering only there it actually drives the system further into paging, How does ARC eviction drives the system further into paging? > because the pager will not recall pages from the swap until they are next > executed. This leads the ARC to try to fill in all the available RAM even > though pages have been pushed off onto swap. Not good. Unused physical memory is a waste. It is true that ARC tries to use as much of memory as it is allowed. The same applies to the page cache (Active, Inactive). Memory management is a dynamic system and there are a few competing agents. It is hard to correctly tune that system using a large hummer such as your patch. I believe that with your patch ARC will get shrunk to its minimum size in due time. Active + Inactive will grow to use the memory that you are denying to ARC driving Free below a threshold, which will reduce ARC. Repeated enough times this will drive ARC to its minimum. Also, there are a few technical problems with the patch: - you don't need to use sysctl interface in kernel, the values you need are available directly, just take a look at e.g. implementation of vm_paging_needed() - similarly, querying vfs.zfs.arc_freepage_percent_target value via kernel_sysctlbyname is just bogus; you can use percent_target directly - you don't need to sum various page counters to get a total count, there is v_page_count Lastly, can you try to test reverting your patch and instead setting vm.lowmem_period=0 ? -- Andriy Gapon 755207 4 karl 2014-03-19 14:18:40 +0000 On 3/18/2014 12:19 PM, Karl Denninger wrote: > > On 3/18/2014 10:20 AM, Andriy Gapon wrote: >> The following reply was made to PR kern/187594; it has been noted by >> GNATS. >> >> From: Andriy Gapon <avg@FreeBSD.org> >> To: bug-followup@FreeBSD.org, karl@fs.denninger.net >> Cc: >> Subject: Re: kern/187594: [zfs] [patch] ZFS ARC behavior problem and fix >> Date: Tue, 18 Mar 2014 17:15:05 +0200 >> >> Karl Denninger <karl@fs.denninger.net> wrote: >> > ZFS can be convinced to engage in pathological behavior due to a bad >> > low-memory test in arc.c >> > >> > The offending file is at >> > /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c; it >> allegedly >> > checks for 25% free memory, and if it is less asks for the cache >> to shrink. >> > >> > (snippet from arc.c around line 2494 of arc.c in 10-STABLE; path >> > /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs) >> > >> > #else /* !sun */ >> > if (kmem_used() > (kmem_size() * 3) / 4) >> > return (1); >> > #endif /* sun */ >> > >> > Unfortunately these two functions do not return what the authors >> thought >> > they did. It's clear what they're trying to do from the >> Solaris-specific >> > code up above this test. >> No, these functions do return what the authors think they do. >> The check is for KVA usage (kernel virtual address space), not for >> physical memory. > I understand, but that's nonsensical in the context of the Solaris > code. "lotsfree" is *not* a declaration of free kvm space, it's a > declaration of when the system has "lots" of free *physical* memory. > > Further it makes no sense at all to allow the ARC cache to force > things into virtual (e.g. swap-space backed) memory. But that's the > behavior that has been observed, and it fits with the code as > originally written. > >> > The result is that the cache only shrinks when >> vm_paging_needed() tests >> > true, but by that time the system is in serious memory trouble >> and by >> No, it is not. >> The description and numbers here are a little bit outdated but they >> should give >> an idea of how paging works in general: >> https://wiki.freebsd.org/AvgPageoutAlgorithm >> > triggering only there it actually drives the system further >> into paging, >> How does ARC eviction drives the system further into paging? > 1. System gets low on physical memory but the ARC cache is looking at > available kvm (of which there is plenty.) The ARC cache continues to > expand. > > 2. vm_paging_needed() returns true and the system begins to page off > to the swap. At the same time the ARC cache is pared down because > arc_reclaim_needed has returned "1". > > 3. As the ARC cache shrinks and paging occurs vm_paging_needed() > returns false. Paging out ceases but inactive pages remain on the > swap. They are not recalled until and unless they are scheduled to > execute. Arc_reclaim_needed again returns "0". > > 4. The hold-down timer expires in the ARC cache code > ("arc_grow_retry", declared as 60 seconds) and the ARC cache begins to > expand again. > > Go back to #2 until the system's performance starts to deteriorate > badly enough due to the paging that you notice it, which occurs when > something that is actually consuming CPU time has to be called in from > swap. > > This is consistent with what I and others have observed on both 9.2 > and 10.0; the ARC will expand until it hits the maximum configured > even at the expense of forcing pages onto the swap. In this specific > machine's case left to defaults it will grab nearly all physical > memory (over 20GB of 24) and wire it down. > > Limiting arc_max to 16GB sorta fixes it. I say "sorta" because it > turns out that 16GB is still too much for the workload; it prevents > the pathological behavior where system "stalls" happen but only in the > extreme. It turns out with the patch in my ARC cache stabilizes at > about 13.5GB during the busiest part of the day, growing to about 16 > off-hours. > > One of the problems with just limiting it in /boot/loader.conf is that > you have to guess and the system doesn't reasonably adapt to changing > memory loads. The code is clearly intended to do that but it doesn't > end up working that way in practice. >> > because the pager will not recall pages from the swap until >> they are next >> > executed. This leads the ARC to try to fill in all the available >> RAM even >> > though pages have been pushed off onto swap. Not good. >> Unused physical memory is a waste. It is true that ARC tries to >> use as much of >> memory as it is allowed. The same applies to the page cache >> (Active, Inactive). >> Memory management is a dynamic system and there are a few competing >> agents. > That's true. However, what the stock code does is force working set > out of memory and into the swap. The ideal situation is one in which > there is no free memory because cache has sized itself to consume > everything *not* necessary for the working set of the processes that > are running. Unfortunately we cannot determine this presciently > because a new process may come along and we do not necessarily know > for how long a process that is blocked on an event will remain blocked > (e.g. something waiting on network I/O, etc.) > > However, it is my contention that you do not want to evict a process > that is scheduled to run (or is going to be) in favor of disk cache > because you're defeating yourself by doing so. The point of the disk > cache is to avoid going to the physical disk for I/O, but if you page > something you have ditched a physical I/O for data in favor of having > to go to physical disk *twice* -- first to write the paged-out data to > swap, and then to retrieve it when it is to be executed. This also > appears to be consistent with what is present for Solaris machines. > > From the Sun code: > > #ifdef sun > /* > * take 'desfree' extra pages, so we reclaim sooner, rather > than later > */ > extra = desfree; > > /* > * check that we're out of range of the pageout scanner. It > starts to > * schedule paging if freemem is less than lotsfree and needfree. > * lotsfree is the high-water mark for pageout, and needfree > is the > * number of needed free pages. We add extra pages here to > make sure > * the scanner doesn't start up while we're freeing memory. > */ > if (freemem < lotsfree + needfree + extra) > return (1); > > /* > * check to make sure that swapfs has enough space so that anon > * reservations can still succeed. anon_resvmem() checks that the > * availrmem is greater than swapfs_minfree, and the number of > reserved > * swap pages. We also add a bit of extra here just to prevent > * circumstances from getting really dire. > */ > if (availrmem < swapfs_minfree + swapfs_reserve + extra) > return (1); > > "freemem" is not virtual memory, it's actual memory. "Lotsfree" is > the point where the system considers free RAM to be "ample"; > "needfree" is the "desperation" point and "extra" is the margin > (presumably for image activation.) > > The base code on FreeBSD doesn't look at physical memory at all; it > looks at kvm space instead. > >> It is hard to correctly tune that system using a large hummer such >> as your >> patch. I believe that with your patch ARC will get shrunk to its >> minimum size >> in due time. Active + Inactive will grow to use the memory that >> you are denying >> to ARC driving Free below a threshold, which will reduce ARC. >> Repeated enough >> times this will drive ARC to its minimum. > I disagree both in design theory and based on the empirical evidence > of actual operation. > > First, I don't (ever) want to give memory to the ARC cache that > otherwise would go to "active", because any time I do that I'm going > to force two page events, which is double the amount of I/O I would > take on a cache *miss*, and even with the ARC at minimum I get a > reasonable hit percentage. If I therefore prefer ARC over "active" > pages I am going to take *at least* a 200% penalty on physical I/O and > if I get an 80% hit ratio with the ARC at a minimum the penalty is > closer to 800%! > > For inactive pages it's a bit more complicated as those may not be > reactivated. However, I am trusting FreeBSD's VM subsystem to demote > those that are unlikely to be reactivated to the cache bucket and then > to "free", where they are able to be re-used. This is consistent with > what I actually see on a running system -- the "inact" bucket is > typically fairly large (often on a busy machine close to that of > "active") but pages demoted to "cache" don't stay there long - they > either get re-promoted back up or they are freed and go on the free list. > > The only time I see "inact" get out of control is when there's a > kernel memory leak somewhere (such as what I ran into the other day > with the in-kernel NAT subsystem on 10-STABLE.) But that's a bug and > if it happens you're going to get bit anyway. > > For example right now on one of my very busy systems with 24GB of > installed RAM and many terabytes of storage across three ZFS pools I'm > seeing 17GB wired of which 13.5 is ARC cache. That's the adaptive > figure it currently is running at, with a maximum of 22.3 and a > minimum of 2.79 (8:1 ratio.) The remainder is wired down for other > reasons (there's a fairly large Postgres server running on that box, > among other things, and it has a big shared buffer declaration -- > that's most of the difference.) Cache hit efficiency is currently 97.8%. > > Active is 2.26G right now, and inactive is 2.09G. Both are stable. > Overnight inactive will drop to about 1.1GB while active will not > change all that much since most of it postgres and the middleware that > talks to it along with apache, which leaves most of its processes > present even when they go idle. Peak load times are about right now > (mid-day), and again when the system is running backups nightly. > > Cache is 7448, in other words, insignificant. Free memory is 2.6G. > > The tunable is set to 10%, which is almost exactly what free memory > is. I find that when the system gets under 1G free transient image > activation can drive it into paging and performance starts to suffer > for my particular workload. > >> Also, there are a few technical problems with the patch: >> - you don't need to use sysctl interface in kernel, the values you >> need are >> available directly, just take a look at e.g. implementation of >> vm_paging_needed() > That's easily fixed. I will look at it. >> - similarly, querying vfs.zfs.arc_freepage_percent_target value via >> kernel_sysctlbyname is just bogus; you can use percent_target directly > I did not know if during setup of the OID the value was copied (and > thus you had to reference it later on) or the entry simply took the > pointer and stashed that. Easily corrected. >> - you don't need to sum various page counters to get a total count, >> there is >> v_page_count > Fair enough as well. >> Lastly, can you try to test reverting your patch and instead setting >> vm.lowmem_period=0 ? > Yes. By default it's 10; I have not tampered with that default. > > Let me do a bit of work and I'll post back with a revised patch. > Perhaps a tunable for percentage free + a free reserve that is a > "floor"? The problem with that is where to put the defaults. One > option would be to grab total size at init time and compute something > similar to what "lotsfree" is for Solaris, allowing that to be tuned > with the percentage if desired. I selected 25% because that's what > the original test was expressing and it should be reasonable for > modest RAM configurations. It's clearly too high for moderately large > (or huge) memory machines unless they have a lot of RAM -hungry > processes running on them. > > The percentage test, however, is an easy knob to twist that is > unlikely to severely harm you if you dial it too far in either > direction; anyone setting it to zero obviously knows what they're > getting into, and if you crank it too high all you end up doing is > limiting the ARC to the minimum value. > Responsive to the criticisms and in an attempt to better-track what the VM system does, I offer this update to the patch. The following changes have been made: 1. There are now two tunables: vfs.zfs.arc_freepages -- the number of free pages below which we declare low memory and ask for ARC paring. vfs.zfs.arc_freepage_percent -- the additional free RAM to reserve in percent of total, if any (added to freepages) 2. vfs.zfs.arc_freepages, if zero (as is the default at boot), defaults to "vm.stats.vm.v_free_target" less 20%. This allows the system to get into the page-stealing paradigm before the ARC cache is invaded. While I do not run into a situation of unbridled inact page growth here the criticism that the original patch could allow this appears to be well-founded. Setting the low memory alert here should prevent this, as the system will now allow the ARC to grow to the point that page-stealing takes place. 3. The previous option to reserve either a hard amount of RAM or a percentage of RAM remains. 4. The defaults should auto-tune for any particular RAM configuration to reasonable values that prevent stalls, yet if you have circumstances that argue for reserving more memory you may do so. Updated patch follows: *** arc.c.original Thu Mar 13 09:18:48 2014 --- arc.c Wed Mar 19 07:44:01 2014 *************** *** 18,23 **** --- 18,99 ---- * * CDDL HEADER END */ + + /* Karl Denninger (karl@denninger.net), 3/18/2014, FreeBSD-specific + * + * If "NEWRECLAIM" is defined, change the "low memory" warning that causes + * the ARC cache to be pared down. The reason for the change is that the + * apparent attempted algorithm is to start evicting ARC cache when free + * pages fall below 25% of installed RAM. This maps reasonably well to how + * Solaris is documented to behave; when "lotsfree" is invaded ZFS is told + * to pare down. + * + * The problem is that on FreeBSD machines the system doesn't appear to be + * getting what the authors of the original code thought they were looking at + * with its test -- or at least not what Solaris did -- and as a result that + * test never triggers. That leaves the only reclaim trigger as the "paging + * needed" status flag, and by the time * that trips the system is already + * in low-memory trouble. This can lead to severe pathological behavior + * under the following scenario: + * - The system starts to page and ARC is evicted. + * - The system stops paging as ARC's eviction drops wired RAM a bit. + * - ARC starts increasing its allocation again, and wired memory grows. + * - A new image is activated, and the system once again attempts to page. + * - ARC starts to be evicted again. + * - Back to #2 + * + * Note that ZFS's ARC default (unless you override it in /boot/loader.conf) + * is to allow the ARC cache to grab nearly all of free RAM, provided nobody + * else needs it. That would be ok if we evicted cache when required. + * + * Unfortunately the system can get into a state where it never + * manages to page anything of materiality back in, as if there is active + * I/O the ARC will start grabbing space once again as soon as the memory + * contention state drops. For this reason the "paging is occurring" flag + * should be the **last resort** condition for ARC eviction; you want to + * (as Solaris does) start when there is material free RAM left BUT the + * vm system thinks it needs to be active to steal pages back in the attempt + * to never get into the condition where you're potentially paging off + * executables in favor of leaving disk cache allocated. + * + * To fix this we change how we look at low memory, declaring two new + * runtime tunables. + * + * The new sysctls are: + * vfs.zfs.arc_freepages (free pages required to call RAM "sufficient") + * vfs.zfs.arc_freepage_percent (additional reservation percentage, default 0) + * + * vfs.zfs.arc_freepages is initialized from vm.stats.vm.v_free_target, + * less 20% if we find that it is zero. Note that vm.stats.vm.v_free_target + * is not initialized at boot -- the system has to be running first, so we + * cannot initialize this in arc_init. So we check during runtime; this + * also allows the user to return to defaults by setting it to zero. + * + * This should insure that we allow the VM system to steal pages first, + * but pare the cache before we suspend processes attempting to get more + * memory, thereby avoiding "stalls." You can set this higher if you wish, + * or force a specific percentage reservation as well, but doing so may + * cause the cache to pare back while the VM system remains willing to + * allow "inactive" pages to accumulate. The challenge is that image + * activation can force things into the page space on a repeated basis + * if you allow this level to be too small (the above pathological + * behavior); the defaults should avoid that behavior but the sysctls + * are exposed should your workload require adjustment. + * + * If we're using this check for low memory we are replacing the previous + * ones, including the oddball "random" reclaim that appears to fire far + * more often than it should. We still trigger if the system pages. + * + * If you turn on NEWRECLAIM_DEBUG then the kernel will print on the console + * status messages when the reclaim status trips on and off, along with the + * page count aggregate that triggered it (and the free space) for each + * event. + */ + + #define NEWRECLAIM + #undef NEWRECLAIM_DEBUG + + /* * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2013 by Delphix. All rights reserved. *************** *** 139,144 **** --- 215,226 ---- #include <vm/vm_pageout.h> + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + #include <sys/sysctl.h> + #endif + #endif /* NEWRECLAIM */ + #ifdef illumos #ifndef _KERNEL /* set with ZFS_DEBUG=watch, to enable watchpoints on frozen buffers */ *************** *** 203,218 **** --- 285,320 ---- int zfs_arc_shrink_shift = 0; int zfs_arc_p_min_shift = 0; int zfs_disable_dup_eviction = 0; + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + static int freepages = 0; /* This much memory is considered critical */ + static int percent_target = 0; /* Additionally reserve "X" percent free RAM */ + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ TUNABLE_QUAD("vfs.zfs.arc_max", &zfs_arc_max); TUNABLE_QUAD("vfs.zfs.arc_min", &zfs_arc_min); TUNABLE_QUAD("vfs.zfs.arc_meta_limit", &zfs_arc_meta_limit); + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + TUNABLE_INT("vfs.zfs.arc_freepages", &freepages); + TUNABLE_INT("vfs.zfs.arc_freepage_percent", &percent_target); + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + SYSCTL_DECL(_vfs_zfs); SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_max, CTLFLAG_RDTUN, &zfs_arc_max, 0, "Maximum ARC size"); SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_min, CTLFLAG_RDTUN, &zfs_arc_min, 0, "Minimum ARC size"); + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + SYSCTL_INT(_vfs_zfs, OID_AUTO, arc_freepages, CTLFLAG_RWTUN, &freepages, 0, "ARC Free RAM Pages Required"); + SYSCTL_INT(_vfs_zfs, OID_AUTO, arc_freepage_percent, CTLFLAG_RWTUN, &percent_target, 0, "ARC Free RAM Target percentage"); + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + /* * Note that buffers can be in one of 6 states: * ARC_anon - anonymous (discussed below) *************** *** 2438,2443 **** --- 2540,2557 ---- { #ifdef _KERNEL + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + u_int vmfree = 0; + u_int vmtotal = 0; + size_t vmsize; + #ifdef NEWRECLAIM_DEBUG + static int xval = -1; + static int oldpercent = 0; + static int oldfreepages = 0; + #endif /* NEWRECLAIM_DEBUG */ + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ if (needfree) return (1); *************** *** 2476,2481 **** --- 2590,2596 ---- return (1); #if defined(__i386) + /* * If we're on an i386 platform, it's possible that we'll exhaust the * kernel heap space before we ever run out of available physical *************** *** 2492,2502 **** return (1); #endif #else /* !sun */ if (kmem_used() > (kmem_size() * 3) / 4) return (1); #endif /* sun */ - #else if (spa_get_random(100) == 0) return (1); #endif --- 2607,2680 ---- return (1); #endif #else /* !sun */ + + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + /* + * Implement the new tunable free RAM algorithm. We check the free pages + * against the minimum specified target and the percentage that should be + * free. If we're low we ask for ARC cache shrinkage. If this is defined + * on a FreeBSD system the older checks are not performed. + * + * Check first to see if we need to init freepages, then test. + */ + if (!freepages) { /* If zero then (re)init */ + vmsize = sizeof(vmtotal); + kernel_sysctlbyname(curthread, "vm.stats.vm.v_free_target", &vmtotal, &vmsize, NULL, 0, NULL, 0); + freepages = vmtotal - (vmtotal / 5); + #ifdef NEWRECLAIM_DEBUG + printf("ZFS ARC: Default vfs.zfs.arc_freepages to [%u] [%u less 20%%]\n", freepages, vmtotal); + #endif /* NEWRECLAIM_DEBUG */ + } + + vmsize = sizeof(vmtotal); + kernel_sysctlbyname(curthread, "vm.stats.vm.v_page_count", &vmtotal, &vmsize, NULL, 0, NULL, 0); + vmsize = sizeof(vmfree); + kernel_sysctlbyname(curthread, "vm.stats.vm.v_free_count", &vmfree, &vmsize, NULL, 0, NULL, 0); + #ifdef NEWRECLAIM_DEBUG + if (percent_target != oldpercent) { + printf("ZFS ARC: Reservation percent change to [%d], [%d] pages, [%d] free\n", percent_target, vmtotal, vmfree); + oldpercent = percent_target; + } + if (freepages != oldfreepages) { + printf("ZFS ARC: Low RAM page change to [%d], [%d] pages, [%d] free\n", freepages, vmtotal, vmfree); + oldfreepages = freepages; + } + #endif /* NEWRECLAIM_DEBUG */ + if (!vmtotal) { + vmtotal = 1; /* Protect against divide by zero */ + /* (should be impossible, but...) */ + } + /* + * Now figure out how much free RAM we require to call the ARC cache status + * "ok". Add the percentage specified of the total to the base requirement. + */ + + if (vmfree < freepages + ((vmtotal / 100) * percent_target)) { + #ifdef NEWRECLAIM_DEBUG + if (xval != 1) { + printf("ZFS ARC: RECLAIM total %u, free %u, free pct (%u), reserved (%u), target pct (%u)\n", vmtotal, vmfree, ((vmfree * 100) / vmtotal), freepages, percent_target); + xval = 1; + } + #endif /* NEWRECLAIM_DEBUG */ + return(1); + } else { + #ifdef NEWRECLAIM_DEBUG + if (xval != 0) { + printf("ZFS ARC: NORMAL total %u, free %u, free pct (%u), reserved (%u), target pct (%u)\n", vmtotal, vmfree, ((vmfree * 100) / vmtotal), freepages, percent_target); + xval = 0; + } + #endif /* NEWRECLAIM_DEBUG */ + return(0); + } + + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + if (kmem_used() > (kmem_size() * 3) / 4) return (1); #endif /* sun */ if (spa_get_random(100) == 0) return (1); #endif -- -- Karl karl@denninger.net 755208 5 karl 2014-03-19 18:03:30 +0000 The 20% invasion of the first-level paging regime looks too aggressive under very heavy load. I have changed my system here to 10% and obtain a better response profile. At 20% the system will still occasionally page recently-used executable code to disk before cache is released which is undesirable. 10% looks better but may STILL be too aggressive (in other words, 5% might be "just right") Being able to tune this in real time is a BIG help! Adjusted patch follows (only a couple of lines have changed) *** arc.c.original Thu Mar 13 09:18:48 2014 --- arc.c Wed Mar 19 13:01:48 2014 *************** *** 18,23 **** --- 18,99 ---- * * CDDL HEADER END */ + + /* Karl Denninger (karl@denninger.net), 3/18/2014, FreeBSD-specific + * + * If "NEWRECLAIM" is defined, change the "low memory" warning that causes + * the ARC cache to be pared down. The reason for the change is that the + * apparent attempted algorithm is to start evicting ARC cache when free + * pages fall below 25% of installed RAM. This maps reasonably well to how + * Solaris is documented to behave; when "lotsfree" is invaded ZFS is told + * to pare down. + * + * The problem is that on FreeBSD machines the system doesn't appear to be + * getting what the authors of the original code thought they were looking at + * with its test -- or at least not what Solaris did -- and as a result that + * test never triggers. That leaves the only reclaim trigger as the "paging + * needed" status flag, and by the time * that trips the system is already + * in low-memory trouble. This can lead to severe pathological behavior + * under the following scenario: + * - The system starts to page and ARC is evicted. + * - The system stops paging as ARC's eviction drops wired RAM a bit. + * - ARC starts increasing its allocation again, and wired memory grows. + * - A new image is activated, and the system once again attempts to page. + * - ARC starts to be evicted again. + * - Back to #2 + * + * Note that ZFS's ARC default (unless you override it in /boot/loader.conf) + * is to allow the ARC cache to grab nearly all of free RAM, provided nobody + * else needs it. That would be ok if we evicted cache when required. + * + * Unfortunately the system can get into a state where it never + * manages to page anything of materiality back in, as if there is active + * I/O the ARC will start grabbing space once again as soon as the memory + * contention state drops. For this reason the "paging is occurring" flag + * should be the **last resort** condition for ARC eviction; you want to + * (as Solaris does) start when there is material free RAM left BUT the + * vm system thinks it needs to be active to steal pages back in the attempt + * to never get into the condition where you're potentially paging off + * executables in favor of leaving disk cache allocated. + * + * To fix this we change how we look at low memory, declaring two new + * runtime tunables. + * + * The new sysctls are: + * vfs.zfs.arc_freepages (free pages required to call RAM "sufficient") + * vfs.zfs.arc_freepage_percent (additional reservation percentage, default 0) + * + * vfs.zfs.arc_freepages is initialized from vm.stats.vm.v_free_target, + * less 10% if we find that it is zero. Note that vm.stats.vm.v_free_target + * is not initialized at boot -- the system has to be running first, so we + * cannot initialize this in arc_init. So we check during runtime; this + * also allows the user to return to defaults by setting it to zero. + * + * This should insure that we allow the VM system to steal pages first, + * but pare the cache before we suspend processes attempting to get more + * memory, thereby avoiding "stalls." You can set this higher if you wish, + * or force a specific percentage reservation as well, but doing so may + * cause the cache to pare back while the VM system remains willing to + * allow "inactive" pages to accumulate. The challenge is that image + * activation can force things into the page space on a repeated basis + * if you allow this level to be too small (the above pathological + * behavior); the defaults should avoid that behavior but the sysctls + * are exposed should your workload require adjustment. + * + * If we're using this check for low memory we are replacing the previous + * ones, including the oddball "random" reclaim that appears to fire far + * more often than it should. We still trigger if the system pages. + * + * If you turn on NEWRECLAIM_DEBUG then the kernel will print on the console + * status messages when the reclaim status trips on and off, along with the + * page count aggregate that triggered it (and the free space) for each + * event. + */ + + #define NEWRECLAIM + #undef NEWRECLAIM_DEBUG + + /* * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2013 by Delphix. All rights reserved. *************** *** 139,144 **** --- 215,226 ---- #include <vm/vm_pageout.h> + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + #include <sys/sysctl.h> + #endif + #endif /* NEWRECLAIM */ + #ifdef illumos #ifndef _KERNEL /* set with ZFS_DEBUG=watch, to enable watchpoints on frozen buffers */ *************** *** 203,218 **** --- 285,320 ---- int zfs_arc_shrink_shift = 0; int zfs_arc_p_min_shift = 0; int zfs_disable_dup_eviction = 0; + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + static int freepages = 0; /* This much memory is considered critical */ + static int percent_target = 0; /* Additionally reserve "X" percent free RAM */ + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ TUNABLE_QUAD("vfs.zfs.arc_max", &zfs_arc_max); TUNABLE_QUAD("vfs.zfs.arc_min", &zfs_arc_min); TUNABLE_QUAD("vfs.zfs.arc_meta_limit", &zfs_arc_meta_limit); + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + TUNABLE_INT("vfs.zfs.arc_freepages", &freepages); + TUNABLE_INT("vfs.zfs.arc_freepage_percent", &percent_target); + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + SYSCTL_DECL(_vfs_zfs); SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_max, CTLFLAG_RDTUN, &zfs_arc_max, 0, "Maximum ARC size"); SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_min, CTLFLAG_RDTUN, &zfs_arc_min, 0, "Minimum ARC size"); + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + SYSCTL_INT(_vfs_zfs, OID_AUTO, arc_freepages, CTLFLAG_RWTUN, &freepages, 0, "ARC Free RAM Pages Required"); + SYSCTL_INT(_vfs_zfs, OID_AUTO, arc_freepage_percent, CTLFLAG_RWTUN, &percent_target, 0, "ARC Free RAM Target percentage"); + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + /* * Note that buffers can be in one of 6 states: * ARC_anon - anonymous (discussed below) *************** *** 2438,2443 **** --- 2540,2557 ---- { #ifdef _KERNEL + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + u_int vmfree = 0; + u_int vmtotal = 0; + size_t vmsize; + #ifdef NEWRECLAIM_DEBUG + static int xval = -1; + static int oldpercent = 0; + static int oldfreepages = 0; + #endif /* NEWRECLAIM_DEBUG */ + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ if (needfree) return (1); *************** *** 2476,2481 **** --- 2590,2596 ---- return (1); #if defined(__i386) + /* * If we're on an i386 platform, it's possible that we'll exhaust the * kernel heap space before we ever run out of available physical *************** *** 2492,2502 **** return (1); #endif #else /* !sun */ if (kmem_used() > (kmem_size() * 3) / 4) return (1); #endif /* sun */ - #else if (spa_get_random(100) == 0) return (1); #endif --- 2607,2680 ---- return (1); #endif #else /* !sun */ + + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + /* + * Implement the new tunable free RAM algorithm. We check the free pages + * against the minimum specified target and the percentage that should be + * free. If we're low we ask for ARC cache shrinkage. If this is defined + * on a FreeBSD system the older checks are not performed. + * + * Check first to see if we need to init freepages, then test. + */ + if (!freepages) { /* If zero then (re)init */ + vmsize = sizeof(vmtotal); + kernel_sysctlbyname(curthread, "vm.stats.vm.v_free_target", &vmtotal, &vmsize, NULL, 0, NULL, 0); + freepages = vmtotal - (vmtotal / 10); + #ifdef NEWRECLAIM_DEBUG + printf("ZFS ARC: Default vfs.zfs.arc_freepages to [%u] [%u less 10%%]\n", freepages, vmtotal); + #endif /* NEWRECLAIM_DEBUG */ + } + + vmsize = sizeof(vmtotal); + kernel_sysctlbyname(curthread, "vm.stats.vm.v_page_count", &vmtotal, &vmsize, NULL, 0, NULL, 0); + vmsize = sizeof(vmfree); + kernel_sysctlbyname(curthread, "vm.stats.vm.v_free_count", &vmfree, &vmsize, NULL, 0, NULL, 0); + #ifdef NEWRECLAIM_DEBUG + if (percent_target != oldpercent) { + printf("ZFS ARC: Reservation percent change to [%d], [%d] pages, [%d] free\n", percent_target, vmtotal, vmfree); + oldpercent = percent_target; + } + if (freepages != oldfreepages) { + printf("ZFS ARC: Low RAM page change to [%d], [%d] pages, [%d] free\n", freepages, vmtotal, vmfree); + oldfreepages = freepages; + } + #endif /* NEWRECLAIM_DEBUG */ + if (!vmtotal) { + vmtotal = 1; /* Protect against divide by zero */ + /* (should be impossible, but...) */ + } + /* + * Now figure out how much free RAM we require to call the ARC cache status + * "ok". Add the percentage specified of the total to the base requirement. + */ + + if (vmfree < freepages + ((vmtotal / 100) * percent_target)) { + #ifdef NEWRECLAIM_DEBUG + if (xval != 1) { + printf("ZFS ARC: RECLAIM total %u, free %u, free pct (%u), reserved (%u), target pct (%u)\n", vmtotal, vmfree, ((vmfree * 100) / vmtotal), freepages, percent_target); + xval = 1; + } + #endif /* NEWRECLAIM_DEBUG */ + return(1); + } else { + #ifdef NEWRECLAIM_DEBUG + if (xval != 0) { + printf("ZFS ARC: NORMAL total %u, free %u, free pct (%u), reserved (%u), target pct (%u)\n", vmtotal, vmfree, ((vmfree * 100) / vmtotal), freepages, percent_target); + xval = 0; + } + #endif /* NEWRECLAIM_DEBUG */ + return(0); + } + + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + if (kmem_used() > (kmem_size() * 3) / 4) return (1); #endif /* sun */ if (spa_get_random(100) == 0) return (1); #endif -- -- Karl karl@denninger.net 755209 6 karl 2014-03-20 12:26:39 +0000 I am increasingly-convinced with increasing runtime now on both synthetic and real loads in production that the proper default value for vfs.zfs.arc_freepages is vm.stats.vm.v_free_target less "just a bit." Five percent appears to be ok for most workloads with RAM configurations ranging from 4GB to the 24GB area (configurations that I can easily test under both synthetic and real environments.) Larger invasions of the free target increasingly risk provocation of the behavior that prompted me to get involved in working this part of the code in the first place, including short-term (~5-10 second) "stalls" during which the system appears to be locked up, but is not. It appears that the key to avoiding that behavior is to not allow the ARC to continue to take RAM when a material invasion of that target space has occurred. -- -- Karl karl@denninger.net 755210 7 avg 2014-03-20 14:56:18 +0000 I think that you are gradually approaching a correct solution to the problem, but from quite a different angle comparing to how I would approach the problem. In fact, I think that it was this commit http://svnweb.freebsd.org/changeset/base/254304 that broke a balance between the page cache and ZFS ARC. On technical side, I see that you are still using kernel_sysctlbyname in your patches. As I've said before, this is not needed and in certain sense incorrect. -- Andriy Gapon 755211 8 karl 2014-03-20 17:00:54 +0000 Responsive to avg's comment and with another overnight and daytime load of testing on multiple machines with varying memory configs from 4-24GB of RAM here is another version of the patch. The differences are: 1. No longer use kernel_sysctlbyname, include the VM header file and get the values directly (less overhead.) Remove the variables no longer needed. 2. Set the default free RAM level for ARC shrinkage to v_free_target less 3% as I was able to provoke a stall once with it set to a 5% reservation, was able to provoke it with the parameter set to 10% with a lot of work and was able to do so "on demand" with it set to 20%. With a 5% invasion initiating a scrub with very heavy I/O and image load (hundreds of web and database processes) provoked a ~10 second system stall. With it set to 3% I have not been able to reproduce the stall yet the inactive page count remains stable even under extremely heavy load, indicating that page-stealing remains effective when required. Note that for my workload even with this level set above v_free_target, which would imply no page stealing by the VM system before ARC expansion is halted, I do not get unbridled inactive page growth. As before vfs.zfs.zrc_freepages and vfs.zfs.arc_freepage_percent remain as accessible knobs if you wish to twist them for some reason to compensate for an unusual load profile or machine configuration. *** arc.c.original Thu Mar 13 09:18:48 2014 --- arc.c Thu Mar 20 11:51:48 2014 *************** *** 18,23 **** --- 18,94 ---- * * CDDL HEADER END */ + + /* Karl Denninger (karl@denninger.net), 3/20/2014, FreeBSD-specific + * + * If "NEWRECLAIM" is defined, change the "low memory" warning that causes + * the ARC cache to be pared down. The reason for the change is that the + * apparent attempted algorithm is to start evicting ARC cache when free + * pages fall below 25% of installed RAM. This maps reasonably well to how + * Solaris is documented to behave; when "lotsfree" is invaded ZFS is told + * to pare down. + * + * The problem is that on FreeBSD machines the system doesn't appear to be + * getting what the authors of the original code thought they were looking at + * with its test -- or at least not what Solaris did -- and as a result that + * test never triggers. That leaves the only reclaim trigger as the "paging + * needed" status flag, and by the time * that trips the system is already + * in low-memory trouble. This can lead to severe pathological behavior + * under the following scenario: + * - The system starts to page and ARC is evicted. + * - The system stops paging as ARC's eviction drops wired RAM a bit. + * - ARC starts increasing its allocation again, and wired memory grows. + * - A new image is activated, and the system once again attempts to page. + * - ARC starts to be evicted again. + * - Back to #2 + * + * Note that ZFS's ARC default (unless you override it in /boot/loader.conf) + * is to allow the ARC cache to grab nearly all of free RAM, provided nobody + * else needs it. That would be ok if we evicted cache when required. + * + * Unfortunately the system can get into a state where it never + * manages to page anything of materiality back in, as if there is active + * I/O the ARC will start grabbing space once again as soon as the memory + * contention state drops. For this reason the "paging is occurring" flag + * should be the **last resort** condition for ARC eviction; you want to + * (as Solaris does) start when there is material free RAM left BUT the + * vm system thinks it needs to be active to steal pages back in the attempt + * to never get into the condition where you're potentially paging off + * executables in favor of leaving disk cache allocated. + * + * To fix this we change how we look at low memory, declaring two new + * runtime tunables. + * + * The new sysctls are: + * vfs.zfs.arc_freepages (free pages required to call RAM "sufficient") + * vfs.zfs.arc_freepage_percent (additional reservation percentage, default 0) + * + * vfs.zfs.arc_freepages is initialized from vm.v_free_target, less 3%. + * This should insure that we allow the VM system to steal pages first, + * but pare the cache before we suspend processes attempting to get more + * memory, thereby avoiding "stalls." You can set this higher if you wish, + * or force a specific percentage reservation as well, but doing so may + * cause the cache to pare back while the VM system remains willing to + * allow "inactive" pages to accumulate. The challenge is that image + * activation can force things into the page space on a repeated basis + * if you allow this level to be too small (the above pathological + * behavior); the defaults should avoid that behavior but the sysctls + * are exposed should your workload require adjustment. + * + * If we're using this check for low memory we are replacing the previous + * ones, including the oddball "random" reclaim that appears to fire far + * more often than it should. We still trigger if the system pages. + * + * If you turn on NEWRECLAIM_DEBUG then the kernel will print on the console + * status messages when the reclaim status trips on and off, along with the + * page count aggregate that triggered it (and the free space) for each + * event. + */ + + #define NEWRECLAIM + #undef NEWRECLAIM_DEBUG + + /* * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2013 by Delphix. All rights reserved. *************** *** 139,144 **** --- 210,222 ---- #include <vm/vm_pageout.h> + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + #include <sys/sysctl.h> + #include <sys/vmmeter.h> + #endif + #endif /* NEWRECLAIM */ + #ifdef illumos #ifndef _KERNEL /* set with ZFS_DEBUG=watch, to enable watchpoints on frozen buffers */ *************** *** 203,218 **** --- 281,316 ---- int zfs_arc_shrink_shift = 0; int zfs_arc_p_min_shift = 0; int zfs_disable_dup_eviction = 0; + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + static int freepages = 0; /* This much memory is considered critical */ + static int percent_target = 0; /* Additionally reserve "X" percent free RAM */ + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ TUNABLE_QUAD("vfs.zfs.arc_max", &zfs_arc_max); TUNABLE_QUAD("vfs.zfs.arc_min", &zfs_arc_min); TUNABLE_QUAD("vfs.zfs.arc_meta_limit", &zfs_arc_meta_limit); + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + TUNABLE_INT("vfs.zfs.arc_freepages", &freepages); + TUNABLE_INT("vfs.zfs.arc_freepage_percent", &percent_target); + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + SYSCTL_DECL(_vfs_zfs); SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_max, CTLFLAG_RDTUN, &zfs_arc_max, 0, "Maximum ARC size"); SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_min, CTLFLAG_RDTUN, &zfs_arc_min, 0, "Minimum ARC size"); + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + SYSCTL_INT(_vfs_zfs, OID_AUTO, arc_freepages, CTLFLAG_RWTUN, &freepages, 0, "ARC Free RAM Pages Required"); + SYSCTL_INT(_vfs_zfs, OID_AUTO, arc_freepage_percent, CTLFLAG_RWTUN, &percent_target, 0, "ARC Free RAM Target percentage"); + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + /* * Note that buffers can be in one of 6 states: * ARC_anon - anonymous (discussed below) *************** *** 2438,2443 **** --- 2536,2546 ---- { #ifdef _KERNEL + #ifdef NEWRECLAIM_DEBUG + static int xval = -1; + static int oldpercent = 0; + static int oldfreepages = 0; + #endif /* NEWRECLAIM_DEBUG */ if (needfree) return (1); *************** *** 2476,2481 **** --- 2579,2585 ---- return (1); #if defined(__i386) + /* * If we're on an i386 platform, it's possible that we'll exhaust the * kernel heap space before we ever run out of available physical *************** *** 2492,2502 **** return (1); #endif #else /* !sun */ if (kmem_used() > (kmem_size() * 3) / 4) return (1); #endif /* sun */ - #else if (spa_get_random(100) == 0) return (1); #endif --- 2596,2658 ---- return (1); #endif #else /* !sun */ + + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + /* + * Implement the new tunable free RAM algorithm. We check the free pages + * against the minimum specified target and the percentage that should be + * free. If we're low we ask for ARC cache shrinkage. If this is defined + * on a FreeBSD system the older checks are not performed. + * + * Check first to see if we need to init freepages, then test. + */ + if (!freepages) { /* If zero then (re)init */ + freepages = cnt.v_free_target - (cnt.v_free_target / 33); + #ifdef NEWRECLAIM_DEBUG + printf("ZFS ARC: Default vfs.zfs.arc_freepages to [%u] [%u less 3%%]\n", freepages, cnt.v_free_target); + #endif /* NEWRECLAIM_DEBUG */ + } + #ifdef NEWRECLAIM_DEBUG + if (percent_target != oldpercent) { + printf("ZFS ARC: Reservation percent change to [%d], [%d] pages, [%d] free\n", percent_target, cnt.v_page_count, cnt.v_free_count); + oldpercent = percent_target; + } + if (freepages != oldfreepages) { + printf("ZFS ARC: Low RAM page change to [%d], [%d] pages, [%d] free\n", freepages, cnt.v_page_count, cnt.v_free_count); + oldfreepages = freepages; + } + #endif /* NEWRECLAIM_DEBUG */ + /* + * Now figure out how much free RAM we require to call the ARC cache status + * "ok". Add the percentage specified of the total to the base requirement. + */ + + if (cnt.v_free_count < freepages + ((cnt.v_page_count / 100) * percent_target)) { + #ifdef NEWRECLAIM_DEBUG + if (xval != 1) { + printf("ZFS ARC: RECLAIM total %u, free %u, free pct (%u), reserved (%u), target pct (%u)\n", cnt.v_page_count, cnt.v_free_count, ((cnt.v_free_count * 100) / cnt.v_page_count), freepages, percent_target); + xval = 1; + } + #endif /* NEWRECLAIM_DEBUG */ + return(1); + } else { + #ifdef NEWRECLAIM_DEBUG + if (xval != 0) { + printf("ZFS ARC: NORMAL total %u, free %u, free pct (%u), reserved (%u), target pct (%u)\n", cnt.v_page_count, cnt.v_free_count, ((cnt.v_free_count * 100) / cnt.v_page_count), freepages, percent_target); + xval = 0; + } + #endif /* NEWRECLAIM_DEBUG */ + return(0); + } + + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + if (kmem_used() > (kmem_size() * 3) / 4) return (1); #endif /* sun */ if (spa_get_random(100) == 0) return (1); #endif -- -- Karl karl@denninger.net 755212 9 karl 2014-03-24 11:41:16 +0000 Update: 1. Patch is still good against latest arc.c change (associated with new flags on the pool). 2. Change default low memory warning for the arc to cnt.v_page_count; no margin. This appears to provide the best performance and does not cause problems with inact pages or other misbehavior on my test systems. 3. Expose the return flag (arc_shrink_needed) so if you care to watch it for some reason, you can. *** arc.c.original Sun Mar 23 14:56:01 2014 --- arc.c Sun Mar 23 15:12:15 2014 *************** *** 18,23 **** --- 18,95 ---- * * CDDL HEADER END */ + + /* Karl Denninger (karl@denninger.net), 3/20/2014, FreeBSD-specific + * + * If "NEWRECLAIM" is defined, change the "low memory" warning that causes + * the ARC cache to be pared down. The reason for the change is that the + * apparent attempted algorithm is to start evicting ARC cache when free + * pages fall below 25% of installed RAM. This maps reasonably well to how + * Solaris is documented to behave; when "lotsfree" is invaded ZFS is told + * to pare down. + * + * The problem is that on FreeBSD machines the system doesn't appear to be + * getting what the authors of the original code thought they were looking at + * with its test -- or at least not what Solaris did -- and as a result that + * test never triggers. That leaves the only reclaim trigger as the "paging + * needed" status flag, and by the time * that trips the system is already + * in low-memory trouble. This can lead to severe pathological behavior + * under the following scenario: + * - The system starts to page and ARC is evicted. + * - The system stops paging as ARC's eviction drops wired RAM a bit. + * - ARC starts increasing its allocation again, and wired memory grows. + * - A new image is activated, and the system once again attempts to page. + * - ARC starts to be evicted again. + * - Back to #2 + * + * Note that ZFS's ARC default (unless you override it in /boot/loader.conf) + * is to allow the ARC cache to grab nearly all of free RAM, provided nobody + * else needs it. That would be ok if we evicted cache when required. + * + * Unfortunately the system can get into a state where it never + * manages to page anything of materiality back in, as if there is active + * I/O the ARC will start grabbing space once again as soon as the memory + * contention state drops. For this reason the "paging is occurring" flag + * should be the **last resort** condition for ARC eviction; you want to + * (as Solaris does) start when there is material free RAM left BUT the + * vm system thinks it needs to be active to steal pages back in the attempt + * to never get into the condition where you're potentially paging off + * executables in favor of leaving disk cache allocated. + * + * To fix this we change how we look at low memory, declaring two new + * runtime tunables and one status. + * + * The new sysctls are: + * vfs.zfs.arc_freepages (free pages required to call RAM "sufficient") + * vfs.zfs.arc_freepage_percent (additional reservation percentage, default 0) + * vfs.zfs.arc_shrink_needed (shows "1" if we're asking for shrinking the ARC) + * + * vfs.zfs.arc_freepages is initialized from vm.v_free_target. + * This should insure that we allow the VM system to steal pages, + * but pare the cache before we suspend processes attempting to get more + * memory, thereby avoiding "stalls." You can set this higher if you wish, + * or force a specific percentage reservation as well, but doing so may + * cause the cache to pare back while the VM system remains willing to + * allow "inactive" pages to accumulate. The challenge is that image + * activation can force things into the page space on a repeated basis + * if you allow this level to be too small (the above pathological + * behavior); the defaults should avoid that behavior but the sysctls + * are exposed should your workload require adjustment. + * + * If we're using this check for low memory we are replacing the previous + * ones, including the oddball "random" reclaim that appears to fire far + * more often than it should. We still trigger if the system pages. + * + * If you turn on NEWRECLAIM_DEBUG then the kernel will print on the console + * status messages when the reclaim status trips on and off, along with the + * page count aggregate that triggered it (and the free space) for each + * event. + */ + + #define NEWRECLAIM + #undef NEWRECLAIM_DEBUG + + /* * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2013 by Delphix. All rights reserved. *************** *** 139,144 **** --- 211,223 ---- #include <vm/vm_pageout.h> + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + #include <sys/sysctl.h> + #include <sys/vmmeter.h> + #endif + #endif /* NEWRECLAIM */ + #ifdef illumos #ifndef _KERNEL /* set with ZFS_DEBUG=watch, to enable watchpoints on frozen buffers */ *************** *** 203,218 **** --- 282,320 ---- int zfs_arc_shrink_shift = 0; int zfs_arc_p_min_shift = 0; int zfs_disable_dup_eviction = 0; + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + static int freepages = 0; /* This much memory is considered critical */ + static int percent_target = 0; /* Additionally reserve "X" percent free RAM */ + static int shrink_needed = 0; /* Shrinkage of ARC cache needed? */ + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ TUNABLE_QUAD("vfs.zfs.arc_max", &zfs_arc_max); TUNABLE_QUAD("vfs.zfs.arc_min", &zfs_arc_min); TUNABLE_QUAD("vfs.zfs.arc_meta_limit", &zfs_arc_meta_limit); + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + TUNABLE_INT("vfs.zfs.arc_freepages", &freepages); + TUNABLE_INT("vfs.zfs.arc_freepage_percent", &percent_target); + TUNABLE_INT("vfs.zfs.arc_shrink_needed", &shrink_needed); + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + SYSCTL_DECL(_vfs_zfs); SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_max, CTLFLAG_RDTUN, &zfs_arc_max, 0, "Maximum ARC size"); SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_min, CTLFLAG_RDTUN, &zfs_arc_min, 0, "Minimum ARC size"); + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + SYSCTL_INT(_vfs_zfs, OID_AUTO, arc_freepages, CTLFLAG_RWTUN, &freepages, 0, "ARC Free RAM Pages Required"); + SYSCTL_INT(_vfs_zfs, OID_AUTO, arc_freepage_percent, CTLFLAG_RWTUN, &percent_target, 0, "ARC Free RAM Target percentage"); + SYSCTL_INT(_vfs_zfs, OID_AUTO, arc_shrink_needed, CTLFLAG_RD, &shrink_needed, 0, "ARC Memory Constrained (0 = no, 1 = yes)"); + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + /* * Note that buffers can be in one of 6 states: * ARC_anon - anonymous (discussed below) *************** *** 2438,2443 **** --- 2540,2550 ---- { #ifdef _KERNEL + #ifdef NEWRECLAIM_DEBUG + static int xval = -1; + static int oldpercent = 0; + static int oldfreepages = 0; + #endif /* NEWRECLAIM_DEBUG */ if (needfree) return (1); *************** *** 2476,2481 **** --- 2583,2589 ---- return (1); #if defined(__i386) + /* * If we're on an i386 platform, it's possible that we'll exhaust the * kernel heap space before we ever run out of available physical *************** *** 2492,2502 **** return (1); #endif #else /* !sun */ if (kmem_used() > (kmem_size() * 3) / 4) return (1); #endif /* sun */ - #else if (spa_get_random(100) == 0) return (1); #endif --- 2600,2664 ---- return (1); #endif #else /* !sun */ + + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + /* + * Implement the new tunable free RAM algorithm. We check the free pages + * against the minimum specified target and the percentage that should be + * free. If we're low we ask for ARC cache shrinkage. If this is defined + * on a FreeBSD system the older checks are not performed. + * + * Check first to see if we need to init freepages, then test. + */ + if (!freepages) { /* If zero then (re)init */ + freepages = cnt.v_free_target; + #ifdef NEWRECLAIM_DEBUG + printf("ZFS ARC: Default vfs.zfs.arc_freepages to [%u]\n", freepages); + #endif /* NEWRECLAIM_DEBUG */ + } + #ifdef NEWRECLAIM_DEBUG + if (percent_target != oldpercent) { + printf("ZFS ARC: Reservation percent change to [%d], [%d] pages, [%d] free\n", percent_target, cnt.v_page_count, cnt.v_free_count); + oldpercent = percent_target; + } + if (freepages != oldfreepages) { + printf("ZFS ARC: Low RAM page change to [%d], [%d] pages, [%d] free\n", freepages, cnt.v_page_count, cnt.v_free_count); + oldfreepages = freepages; + } + #endif /* NEWRECLAIM_DEBUG */ + /* + * Now figure out how much free RAM we require to call the ARC cache status + * "ok". Add the percentage specified of the total to the base requirement. + */ + + if (cnt.v_free_count < (freepages + ((cnt.v_page_count / 100) * percent_target))) { + #ifdef NEWRECLAIM_DEBUG + if (xval != 1) { + printf("ZFS ARC: RECLAIM total %u, free %u, free pct (%u), reserved (%u), target pct (%u)\n", cnt.v_page_count, cnt.v_free_count, ((cnt.v_free_count * 100) / cnt.v_page_count), freepages, percent_target); + xval = 1; + } + #endif /* NEWRECLAIM_DEBUG */ + shrink_needed = 1; + return(1); + } else { + #ifdef NEWRECLAIM_DEBUG + if (xval != 0) { + printf("ZFS ARC: NORMAL total %u, free %u, free pct (%u), reserved (%u), target pct (%u)\n", cnt.v_page_count, cnt.v_free_count, ((cnt.v_free_count * 100) / cnt.v_page_count), freepages, percent_target); + xval = 0; + } + #endif /* NEWRECLAIM_DEBUG */ + shrink_needed = 0; + return(0); + } + + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + if (kmem_used() > (kmem_size() * 3) / 4) return (1); #endif /* sun */ if (spa_get_random(100) == 0) return (1); #endif -- -- Karl karl@denninger.net 755213 10 karl 2014-03-26 12:20:25 +0000 Updated to handle the change in <sys/vmmeter.h> that was recently committed to HEAD and slightly tweak the default reservation to be equal to the VM system's "wakeup" level. This appears, after lots of use in multiple environments, to be the ideal default setting. The knobs remain if you wish to twist then, and I have also exposed the return flag for shrinking being needed should you want to monitor it for some reason. This change to arc.c has made a tremendous (and positive) difference in system behavior and others that are running it have made similar comments. For those having problems with the PR system mangling these patches you can get the below patch via direct fetch at http://www.denninger.net/FreeBSD-Patches/arc-patch *** arc.c.original Sun Mar 23 14:56:01 2014 --- arc.c Tue Mar 25 09:24:14 2014 *************** *** 18,23 **** --- 18,95 ---- * * CDDL HEADER END */ + + /* Karl Denninger (karl@denninger.net), 3/25/2014, FreeBSD-specific + * + * If "NEWRECLAIM" is defined, change the "low memory" warning that causes + * the ARC cache to be pared down. The reason for the change is that the + * apparent attempted algorithm is to start evicting ARC cache when free + * pages fall below 25% of installed RAM. This maps reasonably well to how + * Solaris is documented to behave; when "lotsfree" is invaded ZFS is told + * to pare down. + * + * The problem is that on FreeBSD machines the system doesn't appear to be + * getting what the authors of the original code thought they were looking at + * with its test -- or at least not what Solaris did -- and as a result that + * test never triggers. That leaves the only reclaim trigger as the "paging + * needed" status flag, and by the time * that trips the system is already + * in low-memory trouble. This can lead to severe pathological behavior + * under the following scenario: + * - The system starts to page and ARC is evicted. + * - The system stops paging as ARC's eviction drops wired RAM a bit. + * - ARC starts increasing its allocation again, and wired memory grows. + * - A new image is activated, and the system once again attempts to page. + * - ARC starts to be evicted again. + * - Back to #2 + * + * Note that ZFS's ARC default (unless you override it in /boot/loader.conf) + * is to allow the ARC cache to grab nearly all of free RAM, provided nobody + * else needs it. That would be ok if we evicted cache when required. + * + * Unfortunately the system can get into a state where it never + * manages to page anything of materiality back in, as if there is active + * I/O the ARC will start grabbing space once again as soon as the memory + * contention state drops. For this reason the "paging is occurring" flag + * should be the **last resort** condition for ARC eviction; you want to + * (as Solaris does) start when there is material free RAM left BUT the + * vm system thinks it needs to be active to steal pages back in the attempt + * to never get into the condition where you're potentially paging off + * executables in favor of leaving disk cache allocated. + * + * To fix this we change how we look at low memory, declaring two new + * runtime tunables and one status. + * + * The new sysctls are: + * vfs.zfs.arc_freepages (free pages required to call RAM "sufficient") + * vfs.zfs.arc_freepage_percent (additional reservation percentage, default 0) + * vfs.zfs.arc_shrink_needed (shows "1" if we're asking for shrinking the ARC) + * + * vfs.zfs.arc_freepages is initialized from vm.v_free_target. + * This should insure that we allow the VM system to steal pages, + * but pare the cache before we suspend processes attempting to get more + * memory, thereby avoiding "stalls." You can set this higher if you wish, + * or force a specific percentage reservation as well, but doing so may + * cause the cache to pare back while the VM system remains willing to + * allow "inactive" pages to accumulate. The challenge is that image + * activation can force things into the page space on a repeated basis + * if you allow this level to be too small (the above pathological + * behavior); the defaults should avoid that behavior but the sysctls + * are exposed should your workload require adjustment. + * + * If we're using this check for low memory we are replacing the previous + * ones, including the oddball "random" reclaim that appears to fire far + * more often than it should. We still trigger if the system pages. + * + * If you turn on NEWRECLAIM_DEBUG then the kernel will print on the console + * status messages when the reclaim status trips on and off, along with the + * page count aggregate that triggered it (and the free space) for each + * event. + */ + + #define NEWRECLAIM + #undef NEWRECLAIM_DEBUG + + /* * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2013 by Delphix. All rights reserved. *************** *** 139,144 **** --- 211,230 ---- #include <vm/vm_pageout.h> + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + #include <sys/sysctl.h> + #include <sys/vmmeter.h> + /* + * Struct cnt. was renamed in -head (11-current) at rev 110016; check for it + */ + #if __FreeBSD_version < 1100016 + #define vm_cnt cnt + #endif /* __FreeBSD_version */ + + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + #ifdef illumos #ifndef _KERNEL /* set with ZFS_DEBUG=watch, to enable watchpoints on frozen buffers */ *************** *** 203,218 **** --- 289,327 ---- int zfs_arc_shrink_shift = 0; int zfs_arc_p_min_shift = 0; int zfs_disable_dup_eviction = 0; + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + static int freepages = 0; /* This much memory is considered critical */ + static int percent_target = 0; /* Additionally reserve "X" percent free RAM */ + static int shrink_needed = 0; /* Shrinkage of ARC cache needed? */ + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ TUNABLE_QUAD("vfs.zfs.arc_max", &zfs_arc_max); TUNABLE_QUAD("vfs.zfs.arc_min", &zfs_arc_min); TUNABLE_QUAD("vfs.zfs.arc_meta_limit", &zfs_arc_meta_limit); + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + TUNABLE_INT("vfs.zfs.arc_freepages", &freepages); + TUNABLE_INT("vfs.zfs.arc_freepage_percent", &percent_target); + TUNABLE_INT("vfs.zfs.arc_shrink_needed", &shrink_needed); + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + SYSCTL_DECL(_vfs_zfs); SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_max, CTLFLAG_RDTUN, &zfs_arc_max, 0, "Maximum ARC size"); SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_min, CTLFLAG_RDTUN, &zfs_arc_min, 0, "Minimum ARC size"); + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + SYSCTL_INT(_vfs_zfs, OID_AUTO, arc_freepages, CTLFLAG_RWTUN, &freepages, 0, "ARC Free RAM Pages Required"); + SYSCTL_INT(_vfs_zfs, OID_AUTO, arc_freepage_percent, CTLFLAG_RWTUN, &percent_target, 0, "ARC Free RAM Target percentage"); + SYSCTL_INT(_vfs_zfs, OID_AUTO, arc_shrink_needed, CTLFLAG_RD, &shrink_needed, 0, "ARC Memory Constrained (0 = no, 1 = yes)"); + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + /* * Note that buffers can be in one of 6 states: * ARC_anon - anonymous (discussed below) *************** *** 2438,2443 **** --- 2547,2557 ---- { #ifdef _KERNEL + #ifdef NEWRECLAIM_DEBUG + static int xval = -1; + static int oldpercent = 0; + static int oldfreepages = 0; + #endif /* NEWRECLAIM_DEBUG */ if (needfree) return (1); *************** *** 2476,2481 **** --- 2590,2596 ---- return (1); #if defined(__i386) + /* * If we're on an i386 platform, it's possible that we'll exhaust the * kernel heap space before we ever run out of available physical *************** *** 2492,2502 **** return (1); #endif #else /* !sun */ if (kmem_used() > (kmem_size() * 3) / 4) return (1); #endif /* sun */ - #else if (spa_get_random(100) == 0) return (1); #endif --- 2607,2671 ---- return (1); #endif #else /* !sun */ + + #ifdef NEWRECLAIM + #ifdef __FreeBSD__ + /* + * Implement the new tunable free RAM algorithm. We check the free pages + * against the minimum specified target and the percentage that should be + * free. If we're low we ask for ARC cache shrinkage. If this is defined + * on a FreeBSD system the older checks are not performed. + * + * Check first to see if we need to init freepages, then test. + */ + if (!freepages) { /* If zero then (re)init */ + freepages = vm_cnt.v_free_target; + #ifdef NEWRECLAIM_DEBUG + printf("ZFS ARC: Default vfs.zfs.arc_freepages to [%u]\n", freepages); + #endif /* NEWRECLAIM_DEBUG */ + } + #ifdef NEWRECLAIM_DEBUG + if (percent_target != oldpercent) { + printf("ZFS ARC: Reservation percent change to [%d], [%d] pages, [%d] free\n", percent_target, vm_cnt.v_page_count, vm_cnt.v_free_count); + oldpercent = percent_target; + } + if (freepages != oldfreepages) { + printf("ZFS ARC: Low RAM page change to [%d], [%d] pages, [%d] free\n", freepages, vm_cnt.v_page_count, vm_cnt.v_free_count); + oldfreepages = freepages; + } + #endif /* NEWRECLAIM_DEBUG */ + /* + * Now figure out how much free RAM we require to call the ARC cache status + * "ok". Add the percentage specified of the total to the base requirement. + */ + + if (vm_cnt.v_free_count < (freepages + ((vm_cnt.v_page_count / 100) * percent_target))) { + #ifdef NEWRECLAIM_DEBUG + if (xval != 1) { + printf("ZFS ARC: RECLAIM total %u, free %u, free pct (%u), reserved (%u), target pct (%u)\n", vm_cnt.v_page_count, vm_cnt.v_free_count, ((vm_cnt.v_free_count * 100) / vm_cnt.v_page_count), freepages, percent_target); + xval = 1; + } + #endif /* NEWRECLAIM_DEBUG */ + shrink_needed = 1; + return(1); + } else { + #ifdef NEWRECLAIM_DEBUG + if (xval != 0) { + printf("ZFS ARC: NORMAL total %u, free %u, free pct (%u), reserved (%u), target pct (%u)\n", vm_cnt.v_page_count, vm_cnt.v_free_count, ((vm_cnt.v_free_count * 100) / vm_cnt.v_page_count), freepages, percent_target); + xval = 0; + } + #endif /* NEWRECLAIM_DEBUG */ + shrink_needed = 0; + return(0); + } + + #endif /* __FreeBSD__ */ + #endif /* NEWRECLAIM */ + if (kmem_used() > (kmem_size() * 3) / 4) return (1); #endif /* sun */ if (spa_get_random(100) == 0) return (1); #endif -- -- Karl karl@denninger.net 755214 11 dteske 2014-03-27 21:55:58 +0000 Hi, I can't seem to find the code where you mention in your previous post: `...and slightly tweak the default reservation to be equal to the VM system's "wakeup" level.' Comparing Mar 26th's patch to Mar 24th's patch yields no such change. Did you post the latest patch? -- Devin _____________ The information contained in this message is proprietary and/or confidential. If you are not the intended recipient, please: (i) delete the message and all copies; (ii) do not disclose, distribute or use the message in any manner; and (iii) notify the sender immediately. In addition, please be aware that any message addressed to our domain is subject to archiving and review by persons other than the intended recipient. Thank you. 755215 12 karl 2014-03-28 01:32:17 +0000 The last change was the "cnt" structure rename; the previous rev was the one where freepages was set to cnt.v_free_target (the margin was removed in the rev sent on 24-March in the morning) -- there was no logic change made in the 26th March followup .vs. the previous one from 24 March. The latest that I and others are running is what is on the PR (and the link, which is identical -- a couple people had said they had trouble with the pr followup inclusions being problematic when copied down to be applied.) Apologies for the confusion. -- -- Karl karl@denninger.net 755216 13 karl 2014-04-03 17:57:50 +0000 After more than a week of operation without any changes on a very busy production server this is what the status looks like at this particular moment in time (caught it being pretty quiet at the moment... slow day): [karl@NewFS ~]$ uptime 11:56AM up 10 days, 20:37, 1 user, load averages: 0.80, 0.59, 0.58 [karl@NewFS ~]$ uname -v FreeBSD 10.0-STABLE #22 r263665:263671M: Sun Mar 23 15:00:48 CDT 2014 karl@NewFS.denninger.net:/usr/obj/usr/src/sys/KSD-SMP 1 users Load 0.50 0.57 0.58 Apr 3 11:52 Mem:KB REAL VIRTUAL VN PAGER SWAP PAGER Tot Share Tot Share Free in out in out Act 4503936 32680 9319616 54908 701712 count All 17598k 42312 10162228 293268 pages Proc: Interrupts r p d s w Csw Trp Sys Int Sof Flt ioflt 2635 total 2 245 3 9936 4302 12k 990 442 2878 1161 cow 11 uart0 4 1460 zfod 53 uhci0 16 0.6%Sys 0.1%Intr 1.5%User 0.0%Nice 97.8%Idle ozfod pcm0 17 | | | | | | | | | | %ozfod ehci0 uhci > daefr uhci1 21 dtbuf 1779 prcfr 532 uhci3 ehci Namei Name-cache Dir-cache 485888 desvn 3862 totfr 44 twa0 30 Calls hits % hits % 145761 numvn react 989 cpu0:timer 18611 18549 100 121467 frevn pdwak 69 mps0 256 909 pdpgs 24 em0:rx 0 Disks da0 da1 da2 da3 da4 da5 da6 intrn 32 em0:tx 0 KB/t 10.30 10.39 0.00 0.00 22.61 24.69 24.39 19017980 wire em0:link tps 21 21 0 0 10 16 16 2197580 act 118 em1:rx 0 MB/s 0.22 0.22 0.00 0.00 0.22 0.39 0.39 2544544 inact 107 em1:tx 0 %busy 19 19 0 0 0 1 1 3276 cache em1:link 698064 free ahci0:ch0 buf 32 cpu1:timer 24 cpu10:time 50 cpu6:timer 26 cpu12:time 37 cpu7:timer 45 cpu14:time 41 cpu4:timer 35 cpu15:time 25 cpu5:timer 45 cpu9:timer 45 cpu2:timer 102 cpu11:time 63 cpu3:timer 41 cpu13:time 45 cpu8:timer [karl@NewFS ~]$ zpool list NAME SIZE ALLOC FREE CAP DEDUP HEALTH ALTROOT media 2.72T 2.12T 616G 77% 1.00x ONLINE - zroot 234G 18.8G 215G 8% 1.36x ONLINE - zstore 3.63T 2.50T 1.13T 68% 1.00x ONLINE - [karl@NewFS ~]$ zfs-stats -A ------------------------------------------------------------------------ ZFS Subsystem Report Thu Apr 3 11:53:42 2014 ------------------------------------------------------------------------ ARC Summary: (HEALTHY) Memory Throttle Count: 0 ARC Misc: Deleted: 27.84m Recycle Misses: 1.12m Mutex Misses: 2.65k Evict Skips: 39.26m ARC Size: 59.13% 13.20 GiB Target Size: (Adaptive) 59.14% 13.20 GiB Min Size (Hard Limit): 12.50% 2.79 GiB Max Size (High Water): 8:1 22.33 GiB ARC Size Breakdown: Recently Used Cache Size: 81.41% 10.75 GiB Frequently Used Cache Size: 18.59% 2.46 GiB ARC Hash Breakdown: Elements Max: 2.69m Elements Current: 63.22% 1.70m Collisions: 95.13m Chain Max: 24 Chains: 413.62k ------------------------------------------------------------------------ [karl@NewFS ~]$ zfs-stats -E ------------------------------------------------------------------------ ZFS Subsystem Report Thu Apr 3 11:53:59 2014 ------------------------------------------------------------------------ ARC Efficiency: 1.28b Cache Hit Ratio: 98.37% 1.26b Cache Miss Ratio: 1.63% 20.80m Actual Hit Ratio: 60.07% 766.91m Data Demand Efficiency: 99.15% 435.02m Data Prefetch Efficiency: 20.45% 17.49m CACHE HITS BY CACHE LIST: Anonymously Used: 38.72% 486.24m Most Recently Used: 3.74% 46.94m Most Frequently Used: 57.33% 719.97m Most Recently Used Ghost: 0.06% 792.68k Most Frequently Used Ghost: 0.16% 1.97m CACHE HITS BY DATA TYPE: Demand Data: 34.34% 431.32m Prefetch Data: 0.28% 3.58m Demand Metadata: 23.72% 297.92m Prefetch Metadata: 41.65% 523.09m CACHE MISSES BY DATA TYPE: Demand Data: 17.75% 3.69m Prefetch Data: 66.88% 13.91m Demand Metadata: 5.78% 1.20m Prefetch Metadata: 9.60% 2.00m ------------------------------------------------------------------------ Grinnin' big, in short. I have no reason to make further changes to the code or defaults. -- -- Karl karl@denninger.net 755217 14 karl 2014-04-14 16:40:49 +0000 Follow-up: 21 days at this point of uninterrupted uptime, inact pages are stable as is the free list, wired and free are appropriate and varies with load as expected, ZERO swapping and performance is and has remained excellent, all on a very-heavily used fairly-beefy (~24GB RAM, dual Xeon CPUs) production system under 10-STABLE. -- -- Karl karl@denninger.net 755218 15 dteske 2014-04-14 18:58:09 +0000 Been running this on stable/8 for a week now on 3 separate machines. All appears stable and under heavy load, we can certainly see the new reclaim firing early and appropriately when-needed (no longer do we have programs getting swapped out). Interestingly, in our testing we've found that we can force the old reclaim (code state prior to applying Karl's patch) to fire by sapping the few remaining pages from unallocated memory. I do this by exploiting a little known bug in the bourne-shell to leak memory (command below). sh -c 'f(){ while :;do local b;done;};f' Watching "top" in the un-patched state, we can see Wired memory grow from ARC usage but not drop. I then run the above command and "top" shows an "sh" process with a fast-growing "SIZE", quickly eating up about 100MB per second. When "top" shows the Free memory drop to mere KB (single pages), we see the original (again, unpatched) reclaim algorithm fire and the Wired memory finally starts to drop. After applying this patch, we no longer have to play the game of "eat all my remaining memory to force the original reclaim event to free up pages", but rather the ARC waxes and wanes with normal applicate usage. However, I must say that on stable/8 the problem of applications going to sleep is not nearly as bad as I have experienced it in 9 or 10. We are happy to report that the patch seems to be a win for stable/8 as well because in our case, we do like to have a bit of free memory and the old reclaim was not providing that. It's nice to not have to resort to tricks to get the ARC to pare down. -- Cheers, Devin _____________ The information contained in this message is proprietary and/or confidential. If you are not the intended recipient, please: (i) delete the message and all copies; (ii) do not disclose, distribute or use the message in any manner; and (iii) notify the sender immediately. In addition, please be aware that any message addressed to our domain is subject to archiving and review by persons other than the intended recipient. Thank you. 755219 16 karl 2014-05-15 16:05:34 +0000 I have now been running the latest delta as posted 26 March -- it is coming up on two months now, has been stable here and I've seen several positive reports and no negative ones on impact for others. Performance continues to be "as expected." Is there an expectation on this being merged forward and/or MFC'd? -- -- Karl karl@denninger.net 769779 17 adrian 2014-06-20 16:56:49 +0000 I'll swing alan cox into it and see what he thinks. Thanks! -a 769856 18 fullermd 2014-06-20 20:01:20 +0000 I've also been running the patch (from http://...) for 1-2 weeks now on a couple stable/10 boxes and one -CURRENT, ranging from 4 to 16 gig of RAM. No problems noted, swapping definitely less aggressive so I've not yet waited for anything to swap back in. Doesn't seem to starve the ARC either. 769874 19 adrian 2014-06-20 20:55:21 +0000 From alc: I gave it a cursory look. The patch appears to use "vm_cnt.v_free_target" incorrectly. If you look at sys/vmmeter, specifically, /* * Return TRUE if we have not reached our free page target during * free page recovery operations. */ static __inline int vm_page_count_target(void) { return (vm_cnt.v_free_target > (vm_cnt.v_free_count + vm_cnt.v_cache_count)); } /* * Return the number of pages we need to free-up or cache * A positive number indicates that we do not have enough free pages. */ static __inline int vm_paging_target(void) { return (vm_cnt.v_free_target - (vm_cnt.v_free_count + vm_cnt.v_cache_count)); } you see that "vm_cnt.v_free_target" should be compared to "(vm_cnt.v_free_count + vm_cnt.v_cache_count)" not "vm_cnt.v_free_count". 769883 20 karl 2014-06-20 21:18:34 +0000 No, because memory in "cache" is subject to being either reallocated or freed. When I was developing this patch that was my first impression as well and how I originally coded it, and it turned out to be wrong. The issue here is that you have two parts of the system contending for RAM -- the VM system generally, and the ARC cache. If the ARC cache frees space before the VM system activates and starts pruning then you wind up with the ARC pinned at the minimum after some period of time, because it releases "early." The original ZFS code releases ARC only when the VM system goes into "desperation" mode. That's too late and results in pathological behavior including long freezes where nothing appears to happen at all. What appears to actually be happening is that the ARC is essentially dumped while paging is occurring, and the system reacts very badly to that. The test as it sits now activates the ARC pare-down at the point the VM system wakes up. The two go into and out of contention at roughly the same time resulting in a balanced result -- the ARC stabilizes at a value allowing some cached pages to remain, but cached pages do not grow without boundary nor does the system get into a page starvation situation and get into the "freeze" condition trying to free huge chunks of ARC at once. If you have a need to bias the ARC pare-down more-aggressively you can through the tunables, but the existing code is where after much experimentation across multiple workloads and RAM sizes was found to result in both a stable ARC and stable cache page population over long periods of time (weeks of uptime across varying loads.) As currently implemented this has now been running untouched for several months on an extremely busy web, database (Postgresql) and internal Samba server without incident. 772572 21 ebay 2014-07-10 02:30:49 +0000 I have been using this patch for a while on two desktops (4G and 16G) and my swapping activity has stopped with no visible negative impact. Positive impact for me is no longer having to wait for applications to swap back in when I need to use them. I tried r265945 and vm.lowmem_period=0 and neither were as effective as the patch in this bug report. I plan to roll this patch into my next build for general deployment to my servers and start experimenting with removing my vfs.zfs.arc_max setting which I am currently using on some. I hope it can gain enough consensus to at least commit to -current. Thanks. 774784 22 mmoll 2014-07-26 01:49:30 +0000 any news on this? especially regarding 10.1? 780798 23 karl 2014-08-20 15:28:57 +0000 Status -- still grinning, still doing what it's supposed to on my fairly-heavily loaded production machine..... This machine has a large Postgres database running on it and has 19Gb of RAM wired at the present time. Are there any further comments from the reviewers on integration into the tree for general distribution? [karl@NewFS ~]$ uname -v FreeBSD 10.0-STABLE #0 r265164M: Wed Apr 30 16:55:42 CDT 2014 karl@NewFS.denninger.net:/usr/obj/usr/src/sys/KSD-SMP [karl@NewFS ~]$ uptime 10:24AM up 111 days, 16:56, 1 user, load averages: 0.43, 0.55, 0.51 [karl@NewFS ~]$ zfs-stats -AE ------------------------------------------------------------------------ ZFS Subsystem Report Wed Aug 20 10:24:49 2014 ------------------------------------------------------------------------ ARC Summary: (HEALTHY) Memory Throttle Count: 0 ARC Misc: Deleted: 146.88m Recycle Misses: 6.59m Mutex Misses: 14.19k Evict Skips: 176.63m ARC Size: 65.19% 14.56 GiB Target Size: (Adaptive) 65.19% 14.56 GiB Min Size (Hard Limit): 12.50% 2.79 GiB Max Size (High Water): 8:1 22.33 GiB ARC Size Breakdown: Recently Used Cache Size: 78.62% 11.44 GiB Frequently Used Cache Size: 21.38% 3.11 GiB ARC Hash Breakdown: Elements Max: 1.61m Elements Current: 61.38% 986.56k Collisions: 653.96m Chain Max: 27 Chains: 243.95k ------------------------------------------------------------------------ ARC Efficiency: 6.56b Cache Hit Ratio: 98.75% 6.48b Cache Miss Ratio: 1.25% 81.95m Actual Hit Ratio: 82.14% 5.39b Data Demand Efficiency: 99.56% 3.83b Data Prefetch Efficiency: 23.05% 53.24m CACHE HITS BY CACHE LIST: Anonymously Used: 16.46% 1.07b Most Recently Used: 4.48% 289.87m Most Frequently Used: 78.70% 5.10b Most Recently Used Ghost: 0.07% 4.50m Most Frequently Used Ghost: 0.29% 18.94m CACHE HITS BY DATA TYPE: Demand Data: 58.89% 3.81b Prefetch Data: 0.19% 12.27m Demand Metadata: 17.85% 1.16b Prefetch Metadata: 23.07% 1.49b CACHE MISSES BY DATA TYPE: Demand Data: 20.38% 16.70m Prefetch Data: 49.99% 40.97m Demand Metadata: 16.74% 13.72m Prefetch Metadata: 12.89% 10.56m ------------------------------------------------------------------------ 780799 24 Mark.Martinec 2014-08-20 15:31:00 +0000 Please don't miss the 10.1 slush! The fix is still not in 10-STABLE and needs to be manually applied for each new 10 installation. 781353 25 fullermd 2014-08-23 11:37:55 +0000 Having run it for a few months on a number of boxes now, my general impression is that it seems like it goes a little _too_ far (with default options anyway; I haven't tried any tuning) toward making the ARC give up its lunch money to anybody who looks threateningly at it. It feels like it should be a bit more aggressive, and historically was and did fine. However, it's still _much_ nicer than the unpatched case, where the rest of the system starves and hides out in the swap space. So from here, while perhaps imperfect and in need of some tuning work, it's still a significant improvement on the prior state, so landing it sounds just fine to me. 781382 26 smh 2014-08-23 14:16:38 +0000 I've actually been looking at this patch today in relation to my investigation of: https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=191510 I would appreciate it if people could test the attached patch, which was created against stable/10 It should achieve the same as Karl's patch as well as: * More closely matching original Solaris logic * Provide better control of the reclaim trigger (absolute not percentage based, which becomes a problem in larger memory machines) * Uses direct kernel values instead of interfacing via sysctl's. * Should fix the issue identified in #191510 as well. Basic design is it will trigger ARC reclaim when free pages drops below vfs.zfs.arc_free_target, which by default is 3 x that of the VM's target free pages as exposed by vm.v_free_target (matching Solaris). 781384 27 146178 smh 2014-08-23 14:18:50 +0000 Created attachment 146178 refactor arc reclaim logic 781594 28 146203 smh 2014-08-24 09:05:40 +0000 Created attachment 146203 refactor arc reclaim logic 781743 29 karl 2014-08-24 18:12:53 +0000 Steve; I don't think you're going to like what your patch does under load. If I'm reading it correctly you are basically paring ARC down when vm_free_target * 3 is invaded -- that is: (zfs_arc_free_target = kmem_free_target_size() * 3;) If I'm reading this correctly at three times the free target size you will pare ARC back. When I allowed there to be a margin between ARC paring and the vm system's target free page space what ultimately happened under load was that the ARC cache was pinned to the minimum value because the VM system never woke up to reclaim any of the reserved but not-in-active-use space. I believe that the reason for this is the basic design of the unified VM system in FreeBSD; pages are allowed to "float" on the premise that they may be re-used, which is fine in the general case and in fact improves performance but when you have ARC cache that can only be allocated out of actual free memory that "floating" space winds up pinning the ARC to the floor as ARC is evicted in favor of pages that are not in active use by other parts of the VM system. I went through several iterations of the patch including both a ratio-based and fixed reservation over v_free_target with all of those attempts winding up with corner cases that led to bad outcomes; after much work the last update I posted defaults to this: (freepages = vm_cnt.v_free_target;) That results in ARC pare-back and VM page-cleaning wakeup happening at the same time. You can tune the defaults away from that, but I have found that doing so in the general case leads to undesired outcomes, either with the ARC being pinned to zero or the "hangs" (really long pauses) returning. I left the tunables in for those cases where a workload other than what I had encountered made them wise, although from the comments over the last three months I suspect they could be removed since those knobs appear to be far more-likely to hurt than help. It would appear that what I settled on is the wrong decision by the original code comments, but that code assumes VM behavior that is different than what FreeBSD actually does. There may be a valid debate to be had on altering FreeBSD's VM behavior via page coloration or somesuch so that ARC has "preference" over things like inactive or (especially) cached pages -- but without that sort of change I believe what you've proposed is going to run into a problem with system behavior under load similar to what I saw when I attempted to pare back ARC before VM page-cleaning wakes up. From the production system here and my various test systems, this is what produces a stable operating environment: vm.v_free_target: 130321 vm.stats.vm.v_free_target: 130321 [karl@NewFS ~]$ sysctl -a|grep arc_freepage vfs.zfs.arc_freepages: 130321 vfs.zfs.arc_freepage_percent: 0 In other words both ARC paring and VM wake up at the same time, no additional reservation beyond free_target is requested. If I tune vfs.zfs.arc_freepages up from that value manually by any material amount (e.g. to 3x value that I think you're setting it to) I will end up pinning the ARC cache to the floor on my servers within a relatively short period of time. 781790 30 smh 2014-08-24 19:02:35 +0000 That's not what we've experienced here on a box running a nginx reverse proxy which is under high memory load from ZFS ARC we see:- ------------------------------------------------------------------------ ZFS Subsystem Report Sun Aug 24 18:49:13 2014 ------------------------------------------------------------------------ ARC Summary: (HEALTHY) Memory Throttle Count: 0 ARC Misc: Deleted: 73.95m Recycle Misses: 4.08m Mutex Misses: 30.34k Evict Skips: 4.98m ARC Size: 93.63% 174.17 GiB Target Size: (Adaptive) 93.63% 174.17 GiB Min Size (Hard Limit): 12.50% 23.25 GiB Max Size (High Water): 8:1 186.01 GiB ARC Size Breakdown: Recently Used Cache Size: 76.28% 132.86 GiB Frequently Used Cache Size: 23.72% 41.31 GiB ARC Hash Breakdown: Elements Max: 5.44m Elements Current: 100.00% 5.44m Collisions: 9.36m Chain Max: 8 Chains: 533.83k ------------------------------------------------------------------------ If by default your patch results in freepages = vm_cnt.v_free_target you'll always be hitting if (vm_paging_needed()) { Also the percentage method results in massive amounts of unused memory. On the box from above 40GB was never used, which is clearly a problem. I'd be really be interest if you can test and confirm if you do indeed experience what you believe might happen with your workload. 781821 31 karl 2014-08-24 20:38:21 +0000 Can I replicate your patch's behavior by tuning vfs.zfs.arc_freepages to vm_v_free_target * 3, using the patch I have in? (this link here: https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=187594#c10) I think so if I'm reading your patch correctly. If so then I can do that test "hot" since my patch allows "online" tuning of that parameter and I will know in a few hours during the business day (and maybe quite quickly this evening, although our load is much lower at night and on weekends.) The patch at the above link is not a percentage-based reservation; this is what I have now on the machine in question that has been running my patch in production: [karl@NewFS ~]$ systat -vm 1 users Load 0.70 0.65 0.58 Aug 24 15:25 Mem:KB REAL VIRTUAL VN PAGER SWAP PAGER Tot Share Tot Share Free in out in out Act 4252540 33548 8746752 69996 650840 count All 17358k 51460 9688212 255976 pages Proc: Interrupts r p d s w Csw Trp Sys Int Sof Flt ioflt 6733 total 237 3 22k 6650 14k 3866 441 2700 1197 cow 11 uart0 4 1286 zfod 154 uhci0 16 0.9%Sys 0.3%Intr 2.0%User 0.0%Nice 96.7%Idle ozfod pcm0 17 | | | | | | | | | | %ozfod ehci0 uhci +> daefr uhci1 21 dtbuf 1889 prcfr 527 uhci3 ehci Namei Name-cache Dir-cache 485888 desvn 6640 totfr 131 twa0 30 Calls hits % hits % 143890 numvn react 1003 cpu0:timer 11904 11816 99 121463 frevn pdwak 123 mps0 256 631 pdpgs 1387 em0:rx 0 Disks da0 da1 da2 da3 da4 da5 da6 intrn 1353 em0:tx 0 KB/t 23.86 23.78 0.00 0.00 91.68 89.02 87.34 19287356 wire em0:link tps 51 50 0 0 25 37 38 1538432 act 84 em1:rx 0 MB/s 1.18 1.17 0.00 0.00 2.22 3.21 3.24 2984088 inact 97 em1:tx 0 %busy 37 35 0 0 2 2 3 23764 cache em1:link 627204 free 226 cpu1:timer 96 buf 61 cpu8:timer 212 cpu7:timer 71 cpu11:time 137 cpu3:timer 48 cpu12:time 94 cpu6:timer 60 cpu15:time 185 cpu5:timer 74 cpu10:time 220 cpu4:timer 105 cpu13:time 170 cpu2:timer 105 cpu9:timer 95 cpu14:time That's not much in the way of free RAM up there... This is what zfs-stats -AE shows: [karl@NewFS ~]$ zfs-stats -AE ------------------------------------------------------------------------ ZFS Subsystem Report Sun Aug 24 15:31:24 2014 ------------------------------------------------------------------------ ARC Summary: (HEALTHY) Memory Throttle Count: 0 ARC Misc: Deleted: 153.75m Recycle Misses: 6.79m Mutex Misses: 14.80k Evict Skips: 182.26m ARC Size: 59.18% 13.21 GiB Target Size: (Adaptive) 59.18% 13.21 GiB Min Size (Hard Limit): 12.50% 2.79 GiB Max Size (High Water): 8:1 22.33 GiB ARC Size Breakdown: Recently Used Cache Size: 87.08% 11.51 GiB Frequently Used Cache Size: 12.92% 1.71 GiB ARC Hash Breakdown: Elements Max: 1.61m Elements Current: 47.36% 761.34k Collisions: 680.92m Chain Max: 27 Chains: 174.04k ------------------------------------------------------------------------ ARC Efficiency: 6.77b Cache Hit Ratio: 98.75% 6.69b Cache Miss Ratio: 1.25% 84.90m Actual Hit Ratio: 82.47% 5.59b Data Demand Efficiency: 99.56% 4.00b Data Prefetch Efficiency: 23.02% 55.39m CACHE HITS BY CACHE LIST: Anonymously Used: 16.12% 1.08b Most Recently Used: 4.50% 300.76m Most Frequently Used: 79.02% 5.28b Most Recently Used Ghost: 0.07% 4.66m Most Frequently Used Ghost: 0.29% 19.71m CACHE HITS BY DATA TYPE: Demand Data: 59.49% 3.98b Prefetch Data: 0.19% 12.75m Demand Metadata: 17.78% 1.19b Prefetch Metadata: 22.53% 1.51b CACHE MISSES BY DATA TYPE: Demand Data: 20.67% 17.55m Prefetch Data: 50.23% 42.64m Demand Metadata: 16.54% 14.04m Prefetch Metadata: 12.56% 10.66m ------------------------------------------------------------------------ As you can see there's plenty of contention for RAM in that the dynamic size of the ARC cache is about HALF of the maximum permitted. However, RAM is not sitting around unused; the system is appropriately managing that memory between other VM uses and that of ARC cache. It's doing great in terms of efficiency, given that it's got a near-99% hit ratio. Point being that there would be effectively no gain to forcing more ARC usage, especially if it comes at the expense of (any) paging -- the system is doing zero of that and has nothing (effectively) paged out: [karl@NewFS ~]$ pstat -s Device 1K-blocks Used Avail Capacity /dev/gpt/swap1.eli 67108864 692 67108172 0% That system is a dual Xeon E5620 machine with 24GB of ECC RAM in it. It has a Postgres database, an Apache web server and a bunch of middleware running on it and has been up for about three months now untouched. It's pretty unloaded at the moment (as you can see) but gets a ton of traffic during the business day. 781936 32 smh 2014-08-25 10:32:32 +0000 I'll be honest I hadn't seen the inline patch. Can you attach the latest version so I can compare that to the original. 781937 33 146249 smh 2014-08-25 10:35:12 +0000 Created attachment 146249 arc reclaim refactor (against head) 781952 34 146251 karl 2014-08-25 12:52:47 +0000 Created attachment 146251 From comment #10 781953 35 karl 2014-08-25 12:53:25 +0000 (In reply to Steven Hartland from comment #32) > I'll be honest I hadn't seen the inline patch. Can you attach the latest > version so I can compare that to the original. Done; it's in comment #10. 781955 36 smh 2014-08-25 13:06:05 +0000 What version is that against Karl as it fails every hunk against current head? 781959 37 smh 2014-08-25 13:28:15 +0000 Figured it out patch is in dos not unix format ;-) 781969 38 karl 2014-08-25 14:09:40 +0000 (In reply to Steven Hartland from comment #37) > Figured it out patch is in dos not unix format ;-) Bugzilla did that; all I did was copy the patch in comment #10 and paste it in the "Add an attachment" box! I suppose I should file a pr on the pr system ;-) 782027 39 smh 2014-08-25 18:02:59 +0000 The difference between the two approaches in the default config is:- if (vm_cnt.v_free_count < vm_cnt.v_free_target) { vs: if (vm_cnt.v_free_count < 3 * vm_cnt.v_free_target) { So mine is slightly more conservative with ARC scaling back when free page count drops below 3 x free page target. Currently this is: if (kmem_used() > (kmem_size() * 3) / 4) Which means:- 1. ARC is limited to 3/4 of system memory 2. ARC reclaim can start much later as v_free_count != kmem_size() - kmem_used() but that's no where near the truth. 782046 40 karl 2014-08-25 19:20:35 +0000 That's what I thought from reading your patch. I can tell you what I expect to happen with my configuration if I do that here though (I will confirm later today, as it's easy to do as with my patch I can tune it in real time) -- my ARC is going to get pinned to the floor. Here we go: [root@NewFS /disk/karl]# sysctl -a|grep free_target vm.v_free_target: 130321 vm.stats.vm.v_free_target: 130321 [root@NewFS /disk/karl]# sysctl -w vfs.zfs.arc_freepages=390963 vfs.zfs.arc_freepages: 130321 -> 390963 I'll let it run for a while and report back, but this much I know from my earlier testing and that of others who I shared the early versions with and got feedback from -- my original attempt in fixing this was exactly as you proposed, but with a smaller margin -- that is, to set the ARC release to free_target + a margin; original attempts were anywhere from 10% to 3% of RAM. The problem is that under the right sort of workloads ANY value for ARC paredown above free_target resulted in the ARC being pared back too early as the VM system over time consumed additional page space and the ARC was freed in favor of that other use. From my understanding of how the unified VM system works both from documentation and examining the code this is to be expected; if you allow something else in memory to be evicted on free RAM pressure before the VM system wakes up you will eventually find yourself with none of that (or wherever you set your floor to) since the VM system never wakes up to reclaim its space. As such this is only stable with very large RAM spaces and/or fixed VM loads; if your machine's working set is stable you will probably get away with what your patch does but for mixed workloads (and especially unpredictable ones where wildly-varying requirements for working set exist, or in a system with UFS filesystems as well where traditional buffer caching comes into play) you're going to find that ARC over time gets pinned to the lower limit. That's "stable" in that it doesn't crash but not desirable as it essentially prevents the ARC from using more than minimum RAM any time there is VM contention. The other way is worse and is the default "as shipped" without the patch -- the ARC cache does not pare down until the VM system gets critically low on space and starts paging (rather than simply reclaiming space from the cache and inact buckets.) Once that happens performance goes in the toilet; that's where the "stall" behavior comes from, likely because as the ARC is pared down dramatically and violently you wind up with some pretty ugly interactions between paging activity (dramatically slowing system response in the first place) and a big spike in ARC cache misses that hit you at the same time. While the 3/4 of system memory looks ok at first blush the problem is that for mixed large workloads, especially those that wire pages (e.g. where a DBMS is running) pathological behavior happens early and often. The common refrain heard has always been "add more memory" and just as often "don't run mixed systems with UFS and ZFS filesystems in the same box" but as the patch I put forward shows that's simply neither necessary or (except if you truly go nuts with the RAM) sufficient. There's also a pretty-clean argument to be made that once you get into the mid (and certainly upper) 90% range on cache efficiency having more doesn't do anything for you. Essentially as long as we have a unified VM system that does not provide a "color" for an ARC page (to specify, for example, that it is preferred to keep ARC rather than cache or inact) and you have an external, non-VM-system thread that is managing ARC, to avoid pathology you have to wake up all of contention-management systems for that VM space at the same time. Rewriting the VM system to include ARC management directly and incorporate some sort of page coloration such as is done for cache and inact would be another approach and it was one I considered but it's one that marries the VM system to ZFS in ways that might make maintenance difficult down the road (especially considering that ZFS is an "import" to FreeBSD.) As such I judged the best option to be insuring that both the ARC pare-down and VM cleanup wake up at the same time. To achieve this ARC has to scale back when the VM system wakes up (that is, invasion of v_free_target occurs), not earlier (and DEFINITELY not later!) (There is an advantage to the way I wrote the patch in that if a user wants your patch's behavior instead of the way I wrote it, that is, 3 * v_free_target, they can have it with a run-time tunable that can be set dynamically..... but from my work and testing I don't think that most people with small to moderately-large RAM configurations are going to like the results of doing so.) 782089 41 smh 2014-08-25 21:18:24 +0000 I switched our test machine here to use zfs_arc_free_target = vm_cnt.v_free_target using the sysctl and saw no degradation in performance. ARC reclaim kicked in a little later as expected but based on the existing testing that's happened I'm happy to use that as the default if you believe it changes the behaviour for the better for a wider set of work loads. I don't believe there's a real need for the second sysctl (arc_freepage_percent) as that can be achieved with just the initial one really, and hence is just confusing. The only other material difference is that your sysctl is in pages but the one I'm proposing in bytes. The reason I chose that was its avoids admins having to do the page conversion calculation if they do indeed want to tune the value, as well as it matching the other ZFS tunables which are specified in bytes too. Does anyone prefer pages instead of bytes and if so why? 782095 42 karl 2014-08-25 21:34:36 +0000 Getting rid of the percentage reservation (arc_freepage_percent) is fine; that is effectively an anachronism from earlier rounds of the code. The reason I prefer pages over bytes is that if you do tune it off the default the easy way to get back to defaults is to grab vm.v_free_target out of sysctl. In addition since the code tests against free pages rather than bytes why not use the same unit? Of course there's the other argument on returning to the default, which is that as the patch is written if you set the level to zero it will pick up the default on its own. That means of forcing a re-set to the default should probably be retained. Do you want me to re-work the patch to remove the second tunable and attach it or would you like to? 782116 43 smh 2014-08-26 01:42:36 +0000 No need to do that I wouldn't use the 0 = default code anyway, see how I made that work in my version. 782118 44 karl 2014-08-26 02:39:57 +0000 If I'm reading your code correctly you don't allow the eviction threshold to be tuned during runtime. There's no particular reason I can think of to do that; I know why you did it that way given the init on pagedaemon, but that's why I pick it up if the value is zeroed; that allows the ARC code to pick up the proper value after the rest of VM init is complete, and it also allows the sysadmin to both tell the system to go back to the default or adjust the ARC eviction threshold while the system is running. Why lose that functionality? 782120 45 146287 karl 2014-08-26 02:48:41 +0000 Created attachment 146287 ARC refactor patch less percentage reservation Checked against 10.0-Stable for build integrity; the only change is the removal of the percentage additional reservation (deprecated and not used by default); otherwise identical in operation to patch in comment #10 782216 46 146300 junchoon 2014-08-26 11:45:41 +0000 Created attachment 146300 ARC refactor patch less percentage reservation for after r269846 "ARC refactor patch less percentage reservation" failes at hunk 3 after stable/10 r269846. Please see below svnweb diff. https://svnweb.freebsd.org/base/stable/10/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c?r1=269732&r2=269846 Attached is corrected (minimalistic) patch. Applied and built OK at stable/10 r270646, amd64 and working now on my ThinkPad T420 with 8GB of RAM. 782460 47 smh 2014-08-27 12:14:28 +0000 (In reply to karl from comment #44) > If I'm reading your code correctly you don't allow the eviction threshold to > be tuned during runtime. ... > > Why lose that functionality? Its there sysctl vfs.zfs.arc_free_target 782461 48 146373 smh 2014-08-27 12:20:46 +0000 Created attachment 146373 arc reclaim refactor (against head) Switched arc_free_target to use kmem_free_target_size() instead of kmem_free_target_size() * 3 as the default. I intend to commit this to head later today, with a 1 week MFC period so it can be merged to stable/10 before the freeze for 10.1; so if there are any issues please raise ASAP! 782472 49 karl 2014-08-27 13:01:15 +0000 I'll spin up my test system later today with your iteration on it in place of what's been running and toss a synthetic load at it. 782558 50 jhb 2014-08-27 20:20:12 +0000 (In reply to Steven Hartland from comment #41) > I switched our test machine here to use zfs_arc_free_target = > vm_cnt.v_free_target using the sysctl and saw no degradation in performance. > > ARC reclaim kicked in a little later as expected but based on the existing > testing that's happened I'm happy to use that as the default if you believe > it changes the behaviour for the better for a wider set of work loads. > > I don't believe there's a real need for the second sysctl > (arc_freepage_percent) as that can be achieved with just the initial one > really, and hence is just confusing. > > The only other material difference is that your sysctl is in pages but the > one I'm proposing in bytes. The reason I chose that was its avoids admins > having to do the page conversion calculation if they do indeed want to tune > the value, as well as it matching the other ZFS tunables which are specified > in bytes too. > > Does anyone prefer pages instead of bytes and if so why? All the other VM tunables and stats are in pages (v_*_count, v_*_target, etc.). Please keep it in pages. 782638 51 146423 smh 2014-08-27 23:15:07 +0000 Created attachment 146423 arc reclaim refactor (against head) Switched to using pages instead of bytes for vfs.zfs.arc_free_target as requested by jbh 782639 52 146424 smh 2014-08-27 23:18:01 +0000 Created attachment 146424 arc reclaim refactor (against head) Flag all my old patches as obsolete 782730 53 smh 2014-08-28 10:35:28 +0000 (In reply to karl from comment #49) > I'll spin up my test system later today with your iteration on it in place > of what's been running and toss a synthetic load at it. How did you get on Karl? 782768 54 karl 2014-08-28 12:54:51 +0000 I have only one concern with behavior and that is that when the system came under RAM pressure ARC eviction occurred properly but when that pressure eased the release of space back to ARC was very slow. I believe that my original patch was similarly slow in recovery as RAM pressure eased but want to test that. Expect an updated comment later today.... 782792 55 karl 2014-08-28 15:04:04 +0000 I've got one potential issue against the obsolesced set (the refactor against head will not apply against 10-Stable); one of my test scenarios just produced a material (~30 second) "hang" that I can't reproduce with my patch version on the same box. The scenario is a buildworld/buildkernel/release memstick build; at the end the system allocates a ramdisk to hold the stick image; that allocation sticks a large and sudden RAM load on the VM system and forces ARC eviction. The test system has 12Gb of RAM in it; the expected behavior is that ARC cache gets dumped from ~10Gb down to about 5-6Gb almost instantly when that command runs during the build. I'm looking into it; I must be blind because I don't see why the second hunk is failing against arc.c on your patch when attempted against 10-Stable (checked out today) -- but patch says it does. 782798 56 146456 junchoon 2014-08-28 15:19:36 +0000 Created attachment 146456 arc reclaim refactor (against stable/10) Attached is modified "arc reclaim refactor (against head)" patch for stable/10 for my test. Built and booted OK ATM. Please try if you need. Modified points: *struct vm_cnt* in head is struct cnt* in stable/10. Rename them. *Some tunables are deleted in head. Readd them. 782799 57 junchoon 2014-08-28 15:25:34 +0000 (In reply to Tomoaki AOKI from comment #56) > Created attachment 146456 [details] > arc reclaim refactor (against stable/10) > > Attached is modified "arc reclaim refactor (against head)" patch for > stable/10 for my test. Built and booted OK ATM. Please try if you need. > > Modified points: > *struct vm_cnt* in head is struct cnt* in stable/10. Rename them. > *Some tunables are deleted in head. Readd them. Forgot to mention. https://svnweb.freebsd.org/base/head/sys/sys/vmmeter.h?r1=254304&r2=263620 https://svnweb.freebsd.org/base/head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c?r1=267985&r2=267992 782801 58 karl 2014-08-28 15:28:33 +0000 Got it.... thanks; I had hand-fixed it on this end and am in the middle of rebuilding to re-run the test now. It will take a while; the memstick test requires an hour or more to run from scratch to completion since I do it from a clean build state for consistency reasons. 782809 59 smh 2014-08-28 15:56:08 +0000 (In reply to Tomoaki AOKI from comment #56) > Created attachment 146456 [details] > arc reclaim refactor (against stable/10) > > Attached is modified "arc reclaim refactor (against head)" patch for > stable/10 for my test. Built and booted OK ATM. Please try if you need. Yep that's correct :) 782814 60 karl 2014-08-28 16:56:41 +0000 Looks pretty good with the most-recent against 10-STABLE and arc_free_target at the default value. No misbehavior noted thus far on my test system. It appears the refactor in terms of intent and operation is identical to the Comment 10 patch I had previously posted, and against my synthetic load tests along with "common actions" (e.g. world builds, etc) it behaves identically as well in my testing. 782815 61 smh 2014-08-28 17:10:07 +0000 (In reply to karl from comment #60) > Looks pretty good with the most-recent against 10-STABLE and arc_free_target > at the default value. No misbehavior noted thus far on my test system. > > It appears the refactor in terms of intent and operation is identical to the > Comment 10 patch I had previously posted, and against my synthetic load > tests along with "common actions" (e.g. world builds, etc) it behaves > identically as well in my testing. Thanks Karl your initial work on this and you time testing is much appreciated! 782849 62 smh 2014-08-28 20:07:05 +0000 Addressed by: http://svnweb.freebsd.org/changeset/base/270759 782985 63 smh 2014-08-29 19:37:28 +0000 Karl there's some concern amongst the dev's that we're not counting cache pages as free so could you apply the following to your test machine and retest to see if it has any adverse effects:- Index: cddl/compat/opensolaris/kern/opensolaris_kmem.c =================================================================== --- cddl/compat/opensolaris/kern/opensolaris_kmem.c (revision 270824) +++ cddl/compat/opensolaris/kern/opensolaris_kmem.c (working copy) @@ -152,7 +152,8 @@ kmem_free_count(void) { - return (vm_cnt.v_free_count); + return (vm_cnt.v_free_count + vm_cnt.v_cache_count); } u_int 783004 64 smh 2014-08-29 20:08:10 +0000 I'm aware this has already been tried in the past but if you could retest now so we can eliminate any other issues with the stable/10 which have been fixed in the mean time that would be most appreciated. 783020 65 karl 2014-08-29 20:23:04 +0000 I can give it a shot on my test system but I will note that for my production machine right now that would be a no-op as there are no cache pages in use. Getting that on the production system with a high level of load over the holiday is rather unlikely due to it being Labor Day, so all I will have are my synthetics. I do have some time over the long weekend to run that test and should be able to do so if you think it's useful, but I am wary of that approach being correct in the general case due to my previous experience. My commentary on that discussion point and reasoning originally is here (http://lists.freebsd.org/pipermail/freebsd-fs/2014-March/019084.html); along that thread you'll see a vmstat output with the current paradigm showing that cache doesn't grow without boundary, as many suggested it would if I didn't include those pages as "free" and thus available for ARC to attempt to invade (effectively trying to force the VM system to evict them from the cache list by having it wake up first.) Indeed, up at comment #31 is the patch on that production system that has been up for about four months and you can see only a few pages are in the cached state. That is fairly typical. What is the expected reason for concern about including them in the free count for ARC (when they're not in terms of what wakes up the VM system as a whole.) If the expected area of concern is that cache pages will grow without boundary (or close to it) the evidence from both my production machine and others strongly suggests that's incorrect. My work suggests strongly that the most-likely to be correct behavior for the majority of workloads is achieved when both the ARC paring routine and VM page-cleaning system wake up at the same time. That occurs when vm_cnt.v_free_count is invaded. Attempting to bias the outcome to force either the VM system or the ARC cache to do something first appears to increase the circumstances under which bad behavior occurs. 783024 66 smh 2014-08-29 20:29:56 +0000 Thanks Karl, I'm not a VM domain expert so have forwarded your feedback to the relevant concerned parties in the hope we can come to an educated conclusion. 783036 67 jhb 2014-08-29 21:14:12 +0000 (In reply to karl from comment #65) > My work suggests strongly that the most-likely to be correct behavior for > the majority of workloads is achieved when both the ARC paring routine and > VM page-cleaning system wake up at the same time. That occurs when > vm_cnt.v_free_count is invaded. Attempting to bias the outcome to force > either the VM system or the ARC cache to do something first appears to > increase the circumstances under which bad behavior occurs. I think this last point is precisely why folks like alc@ and peter@ want to include the cache count. All the code in pagedaemon uses 'free + cache' when making decisions. To wit: /* * Return TRUE if we are under our severe low-free-pages threshold * * This routine is typically used at the user<->system interface to determine * whether we need to block in order to avoid a low memory deadlock. */ static __inline int vm_page_count_severe(void) { return (vm_cnt.v_free_severe > (vm_cnt.v_free_count + vm_cnt.v_cache_count)); } /* * Return TRUE if we are under our minimum low-free-pages threshold. * * This routine is typically used within the system to determine whether * we can execute potentially very expensive code in terms of memory. It * is also used by the pageout daemon to calculate when to sleep, when * to wake waiters up, and when (after making a pass) to become more * desparate. */ static __inline int vm_page_count_min(void) { return (vm_cnt.v_free_min > (vm_cnt.v_free_count + vm_cnt.v_cache_count)); } /* * Return TRUE if we have not reached our free page target during * free page recovery operations. */ static __inline int vm_page_count_target(void) { return (vm_cnt.v_free_target > (vm_cnt.v_free_count + vm_cnt.v_cache_count)); } /* * Return the number of pages we need to free-up or cache * A positive number indicates that we do not have enough free pages. */ static __inline int vm_paging_target(void) { return (vm_cnt.v_free_target - (vm_cnt.v_free_count + vm_cnt.v_cache_count)); } /* * Returns TRUE if the pagedaemon needs to be woken up. */ static __inline int vm_paging_needed(void) { return (vm_cnt.v_free_count + vm_cnt.v_cache_count < vm_pageout_wakeup_thresh); } These are the conditionals that pagedaemon uses to decide how many pages to recycle and when the VM system decides to awaken pagedaemon to recycle pages. As you can clearly see, all of them use 'free + cache' to determine the count of free pages. Thus, if they are going to wakeup at the same time as you wish, they should be using the same triggers. 783038 68 karl 2014-08-29 21:17:20 +0000 I'll toss it on the test machine this weekend; they may well, given the code there, be correct.... 783082 69 karl 2014-08-29 23:05:38 +0000 I remember what it was.... with that as the test cached pages never got pared back and the arc was evicted in favor of it. That's arguably wrong since a page that is in the arc can be recovered if reused very rapidly. I'll see if I can reproduce the bad behavior I previously saw.. I have the test machine running a soak with that proposed change now. 783165 70 karl 2014-08-30 14:10:01 +0000 I was unable to provoke the former bad behavior on my test machine, which is running a current pull from 10-STABLE, with the eviction threshold set to free_count + cache_count. This morning I took the opportunity of the long weekend to backport that to the production system and rebooted it -- will update if I see bad behavior or in a couple of days if not. 783282 71 commit-hook 2014-08-30 21:44:37 +0000 A commit references this bug: Author: smh Date: Sat Aug 30 21:44:33 UTC 2014 New revision: 270861 URL: http://svnweb.freebsd.org/changeset/base/270861 Log: Ensure that ZFS ARC free memory checks include cached pages Also restore kmem_used() check for i386 as it has KVA limits that the raw page counts above don't consider PR: 187594 Reviewed by: peter X-MFC-With: r270759 Review: D700 Sponsored by: Multiplay Changes: head/sys/cddl/compat/opensolaris/kern/opensolaris_kmem.c head/sys/cddl/compat/opensolaris/sys/kmem.h head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c 783655 72 karl 2014-09-01 15:43:06 +0000 Update 9/1: The production system with the ARC cleanup trigger re-compiled to be free + cache pages continues to run well. Perhaps some of others who have tested the original implementation could put this change in as well and make sure it doesn't do bad things to their machines? 784315 73 smh 2014-09-04 18:27:41 +0000 After further discussion we're like to ask users to test setting vfs.zfs.arc_free_target = (vm.stats.vm.v_free_min / 10) * 11 784319 74 146816 smh 2014-09-04 18:42:10 +0000 Created attachment 146816 arc reclaim refactor (against stable/10) Updated patch against stable/10 with all the proposed updates yet to hit the tree at time of writing. 784320 75 146817 smh 2014-09-04 18:44:18 +0000 Created attachment 146817 arc reclam refactor (against head) Updated patch against head with all the proposed updates yet to hit the tree at time of writing. 784324 76 karl 2014-09-04 18:54:19 +0000 Steve; That will result in the VM system going DEEPLY into contention before ARC is freed up on my production system here it will cut the free page count before ARC is freed by 2/3rds! IMHO this will result in forced paging behavior and stalls. I got one stall two nights ago during heavy SMB use (Samba; PCs running backups on an automatic basis) that caused the backup to error out -- and that was with simply including the cache pages in the free list for the comparison (effectively lowering the free memory threshold before the ARC backs off by the cached pages amount.) As it happened overnight I don't know exactly how many pages were in the cache at the time, but it was enough to result in the bad behavior happening again. It did not happen last night, but IMHO even that (relatively minor, in my workload) previous tweak is right on the edge of causing trouble. What is the intended purpose behind driving the VM system that far into RAM contention cleanup before the ARC is pared back? 784342 77 smh 2014-09-04 19:27:10 +0000 (In reply to karl from comment #76) > Steve; > > That will result in the VM system going DEEPLY into contention before ARC is > freed up on my production system here it will cut the free page count before > ARC is freed by 2/3rds! I know that's what you've experienced in the past but we would really like to confirm if this is still true given the combination of these + pagedaemon fixes already in stable/10 and above. I've actually now uploaded the latest revision for both head and stable/10 and so would really appreciate it if you could confirm or deny your suspicions with a test run. > IMHO this will result in forced paging behavior and stalls. We're really looking to confirm this is still the case because there's some belief that this may no longer be the case. > I got one stall two nights ago during heavy SMB use (Samba; PCs running > backups on an automatic basis) that caused the backup to error out -- and > that was with simply including the cache pages in the free list for the > comparison (effectively lowering the free memory threshold before the ARC > backs off by the cached pages amount.) As it happened overnight I don't > know exactly how many pages were in the cache at the time, but it was enough > to result in the bad behavior happening again. It did not happen last > night, but IMHO even that (relatively minor, in my workload) previous tweak > is right on the edge of causing trouble. > > What is the intended purpose behind driving the VM system that far into RAM > contention cleanup before the ARC is pared back? There's a fine line and some complex interactions in play and we're trying to ensure we're not pegging back ARC excessively. I created the following spreadsheet which depicts the values for various scenarios which might be of interest. As you can see it shows that even the most aggressive models proposed leave significant amounts of free RAM on larger machines. https://docs.google.com/spreadsheets/d/1mSL2aH72Vca-phBm7DpACZ-UDeXV15jx4goU1N8Xv-Q/edit?usp=sharing So I know its a pain but as one of the people who has an environment which seems to trigger this behaviour its really important to confirm or deny suspicions with hard results, as I'm sure you'll appreciate. 784349 78 karl 2014-09-04 20:13:16 +0000 I understand but I have a problem with doing that on my production system -- where I can most-easily reproduce the problem. FreeBSD 10.0-STABLE #1 r265164M: Fri Aug 29 23:16:06 CDT 2014 karl@NewFS.denninger.net:/usr/obj/usr/src/sys/KSD-SMP Your patch above will not apply against this rev and I am not willing to move the kernel and userland space up without knowing whether I'm going to get blown to bits as that is a production machine -- and there are reports open right now of serious potential issues with things like devd and lockups (and yes, that machine has USB resources on it.) I can run my synthetics against the test system (which is updated to 10.1-PRERELEASE) but that is not dispositive since I can't produce the same load profile I have on the production machine with it. When were the pagedaemon fixes committed and where can I find a description of them? Specifically, how do they relate (time-wise) to r265164 which is what I'm running now? Why do the developers believe that in a mixed and varying workload including database, SMB and web service that running free RAM down into the 200MB range, strongly implying that a burst of image activation will cause immediate page-out of active working set, is not going to lead to severe performance problems? Note that this allocation would put the free RAM reserve with 24GB of RAM at approximately where it is now for a machine with ONE THIRD of that memory! That configuration almost-certainly can't support that workload at all simply due to the requirement for wired pages (postgres buffer + working memory + apache working set, etc) but a 16GB or 24GB configuration can. Having free RAM run down into the 200MB range on my production system (which is what your spreadsheet implies would be the expected behavior) is, from past experience, going to result in extraordinarily severe performance problems. IMO ARC must be subservient to other demands on physical memory. It's a disk *cache* and I fail to understand how allowing it, under *any* circumstance, to cause any part of the working set to be paged out is a correct decision. Since pagedaemon does not manage ARC it cannot evict it on its own prior to initiating paging; it can only "see" how much RAM is available and in what bucket it lies. Since ARC wires pages those are on the top of the priority queue to be left alone and yet in real terms that's wrong -- but it's unavoidable unless ARC management becomes part of pagedaemon with its own coloration (and that is a massive job with the potential for big trouble as it would effectively divorce huge parts of the imported code base from FreeBSD.) I'm not grokking the complaint here -- the difference in free memory on a 1024GB machine is ~14GB left free, which is a 1.4% difference in overhead. Someone running a 1Tb RAM machine has a damn good reason to stuff that much RAM in the box and yet we're still talking about an overhead of 1.4% -- and that assumes there's nothing very large that will get activated and demand that RAM. 784357 79 smh 2014-09-04 21:04:34 +0000 (In reply to karl from comment #78) > I understand but I have a problem with doing that on my production system -- > where I can most-easily reproduce the problem. > > FreeBSD 10.0-STABLE #1 r265164M: Fri Aug 29 23:16:06 CDT 2014 > karl@NewFS.denninger.net:/usr/obj/usr/src/sys/KSD-SMP > > Your patch above will not apply against this rev and I am not willing to > move the kernel and userland space up without knowing whether I'm going to > get blown to bits as that is a production machine -- and there are reports > open right now of serious potential issues with things like devd and lockups > (and yes, that machine has USB resources on it.) What issues do you see? Might be simple fix I'm guessing the first few hunks of arc.c, due to the recent sysctl changes. > I can run my synthetics against the test system (which is updated to > 10.1-PRERELEASE) but that is not dispositive since I can't produce the same > load profile I have on the production machine with it. > > When were the pagedaemon fixes committed and where can I find a description > of them? Specifically, how do they relate (time-wise) to r265164 which is > what I'm running now? The ones I'm aware of, which may not be all are:- http://svnweb.freebsd.org/base?view=revision&revision=265944 http://svnweb.freebsd.org/base?view=revision&revision=265945 These are after you core revision so unfortunately I think that unfortunately invalidates the testing done so far :( > Why do the developers believe that in a mixed and varying workload including > database, SMB and web service that running free RAM down into the 200MB > range, strongly implying that a burst of image activation will cause > immediate page-out of active working set, is not going to lead to severe > performance problems? Its my understanding that having both ARC and pagedaemon trigger at the same point means an combined effort to clear resources resulting in a good balance. 784364 80 karl 2014-09-04 21:33:22 +0000 I do not believe either of those pagedaemon commits will have a material impact on the system in this regard. At its core the issue is that ARC is a cache, and yet it implemented as *wired* pages, which are sacrosanct. Since there are two separate threads of processing that take care of this, one in the zfs code to handle the ARC pare-down and the other in pagedaemon that handles the various buckets of physical memory, and pagedaemon *can't* hit wired pages (if it could it would be disastrous as you'd be doing I/O to the swap twice instead of taking a cache miss which is one I/O!) this is really only about how prioritization lives between these two threads of processing. The VM system is quiet when free RAM is above "free_target"; when that is invaded VM wakes up and starts looking for things it can either demote or free up. That is the point where contention begins, and arguably where disk cache should stop growing. If contention continues then ARC must lose this contention and the reason is simple -- a disk cache invalidation requires either zero (if the cached item is not requested again) or *one* I/O (if it is) but a page-out requires *at least* one and perhaps *two* -- one to put it on the swap file that cannot be avoided and a second one down the road to recover it if and when necessary. If the argument at its core is that for some configurations the VM system shouldn't allow free RAM to get so large then v_free_target is too large. A burst of memory contention will cause aggressive pare-down of the ARC, but this is IMHO correct behavior as you never want whatever is in ARC to result in I/O on the swap -- that is always a net lose. The patch error is on Hunks #2 and 3, yes -- but from your comment it appears that hand-fixing that doesn't get the people who are objecting what they want. My issue with updating the production system is that the environment there is stable now and given some reports of problems with -STABLE at present I'm loathe to potentially put an unstable environment on that box. I am using a ZFS root so I can certainly clone it and, if necessary, revert, but the disruption from a crash on a production machine no matter how quickly I can roll it back remains substantial. I can put this proposed change on my test box but again, from looking at the comments on those commits to pagedaemon I don't believe they're going to make any difference at all in terms of contention management. The issue that led to me looking at this in the first place is that holding ARC until the pagedaemon has started to consider swapping is pretty easy to argue as "always wrong", and getting close enough to the line that an image activation or RAM request from an application shoves you over the line results in paging activity to the swap that should instead be an eviction of space held by the ARC. As for an argument that this will result in some oscillation of the ARC space that's correct but it's exactly what *should* happen; when memory pressure is low it's perfectly fine to use all the free space for disk caching, but when it's not, no matter how transiently that may be the case, you *never, ever* want to page in an attempt to hold ARC in RAM as you're now trading one prospective physical I/O for two guaranteed ones! It appears that the latest change puts that back in play, and that's exactly what the original patch was intended to, and did, stop. I'll load the test machine this evening later on or tomorrow morning; I have commitments part of this weekend but given how far down into the hole that proposal shoves the eviction decision I will be surprised if I can't get it to misbehave quite easily -- it may be as simple as "cd /usr/src/release;make memstick" on a modest (e.g. 8-12Gb RAM) machine as that procedure allocates a nice fat memdisk during the process. 784396 81 karl 2014-09-05 03:18:35 +0000 The "against stable/10" patch applies against a current checkout (sys directory claims to be 271151, checked out within the last hour) but does not build. 784397 82 karl 2014-09-05 03:25:37 +0000 (In reply to karl from comment #81) > The "against stable/10" patch applies against a current checkout (sys > directory claims to be 271151, checked out within the last hour) but does > not build. Never mind -- looks like something didn't apply (odd); beginning testing now. 784401 83 karl 2014-09-05 03:40:20 +0000 Uh, this is *definitely* wrong (against STABLE-10) $ sysctl -a|grep arc_free_target vfs.zfs.arc_free_target: 0 It appears you're grabbing that value before pageout_wakeup_thresh has initialized. I'll set it to vm.pageout_wakeup_thresh, warm up the cache and see what I get. 784402 84 karl 2014-09-05 04:05:18 +0000 The latest patch against STABLE blows up "make buildworld" here: --- cddl/lib__L --- /usr/src/cddl/lib/libzpool/../../../sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c:247:8: warning: implicit declaration of function 'sysctl_handle_int' is invalid in C99 [-Wimplicit-function-declaration] err = sysctl_handle_int(oidp, &val, 0, req); ^ /usr/src/cddl/lib/libzpool/../../../sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c:251:12: error: use of undeclared identifier 'minfree' if (val < minfree) ^ /usr/src/cddl/lib/libzpool/../../../sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c:253:12: error: use of undeclared identifier 'cnt' if (val > cnt.v_page_count) ^ --- lib__L --- --- depend_subdir_libllvmx86codegen --- --- X86GenInstrInfo.inc.h --- tblgen -gen-instr-info -I /usr/src/lib/clang/libllvmx86codegen/../../../contrib/llvm/include -I /usr/src/lib/clang/libllvmx86codegen/../../../contrib/llvm/lib/Target/X86 -d X86GenInstrInfo.inc.d -o X86GenInstrInfo.inc.h /usr/src/lib/clang/libllvmx86codegen/../../../contrib/llvm/lib/Target/X86/X86.td --- cddl/lib__L --- 1 warning and 2 errors generated. *** [arc.So] Error code 1 root@dbms2:/usr/src # svn update . At revision 271152. Current as of this time (9/4 23:03) 784423 85 smh 2014-09-05 08:26:16 +0000 Investigating, I'm assuming the patch applied cleanly in the end? 784430 86 146851 smh 2014-09-05 09:15:24 +0000 Created attachment 146851 arc reclaim refactor (against stable/10) Updated patch against stable/10 to fix world build 784431 87 146852 smh 2014-09-05 09:15:57 +0000 Created attachment 146852 arc reclam refactor (against head) Updated patch against head to fix world build 784434 88 146854 smh 2014-09-05 09:30:48 +0000 Created attachment 146854 arc reclaim refactor (against stable/10) Add missing changes to pagedaemon which meant arc_free_target was initialised to 0 by stable/10 patch 784447 89 146859 smh 2014-09-05 11:45:29 +0000 Created attachment 146859 arc reclaim refactor (against stable/10) Added missing machine/vmparam.h include causing all platforms to take the small memory code paths 784449 90 146861 smh 2014-09-05 11:46:32 +0000 Created attachment 146861 arc reclam refactor (against head) 784451 91 smh 2014-09-05 11:53:58 +0000 Sorry Karl there was a fairly major issue with the version you have in test. I've updated the patches to fix that. 784453 92 karl 2014-09-05 12:47:46 +0000 BTW on the production system, which is running with the free + cache level set, I have now gotten a *second* stall during overnight backups from the PCs attached to that server (this generates very heavy SMB traffic over gigabit links.) This is one of the paradigms that has historically generated problems -- and it's back with that single change. The other changes are NOT in. So for that system allowing invasion of v_free_target is empirically wrong. I will see what I can get done today with the test machine and the new patch. 784454 93 karl 2014-09-05 12:58:57 +0000 (In reply to karl from comment #92) > BTW on the production system, which is running with the free + cache level > set, I have now gotten a *second* stall during overnight backups from the > PCs attached to that server (this generates very heavy SMB traffic over > gigabit links.) This is one of the paradigms that has historically > generated problems -- and it's back with that single change. The other > changes are NOT in. So for that system allowing invasion of v_free_target > is empirically wrong. > > I will see what I can get done today with the test machine and the new patch. Incidentally I just reproduced the I/O freeze on the production machine. That patch to allow invading v_free_target is being backed out this morning due to necessity -- whether I can get this newer version spun up and can take the risk of bad behavior there is an open question *but the question as to whether allowing cache pages to be included has been answered on my production machine with the rev it is running, and the answer is NO!* 784456 94 smh 2014-09-05 13:17:25 +0000 (In reply to karl from comment #93) > (In reply to karl from comment #92) > > BTW on the production system, which is running with the free + cache level > > set, I have now gotten a *second* stall during overnight backups from the > > PCs attached to that server (this generates very heavy SMB traffic over > > gigabit links.) This is one of the paradigms that has historically > > generated problems -- and it's back with that single change. The other > > changes are NOT in. So for that system allowing invasion of v_free_target > > is empirically wrong. > > > > I will see what I can get done today with the test machine and the new patch. > > Incidentally I just reproduced the I/O freeze on the production machine. > That patch to allow invading v_free_target is being backed out this morning > due to necessity -- whether I can get this newer version spun up and can > take the risk of bad behavior there is an open question *but the question as > to whether allowing cache pages to be included has been answered on my > production machine with the rev it is running, and the answer is NO!* Interesting what are you seeing for: sysctl vm.stats.vm 784459 95 karl 2014-09-05 13:20:28 +0000 [karl@NewFS ~]$ sysctl vm.stats.vm vm.stats.vm.v_vm_faults: 123526970 vm.stats.vm.v_io_faults: 4387 vm.stats.vm.v_cow_faults: 46190876 vm.stats.vm.v_cow_optim: 45120 vm.stats.vm.v_zfod: 61801534 vm.stats.vm.v_ozfod: 7933 vm.stats.vm.v_swapin: 0 vm.stats.vm.v_swapout: 9 vm.stats.vm.v_swappgsin: 0 vm.stats.vm.v_swappgsout: 77 vm.stats.vm.v_vnodein: 4718 vm.stats.vm.v_vnodeout: 19311 vm.stats.vm.v_vnodepgsin: 29858 vm.stats.vm.v_vnodepgsout: 27672 vm.stats.vm.v_intrans: 1843 vm.stats.vm.v_reactivated: 4503 vm.stats.vm.v_pdwakeups: 3 vm.stats.vm.v_pdpages: 89932869 vm.stats.vm.v_tcached: 17313 vm.stats.vm.v_dfree: 0 vm.stats.vm.v_pfree: 71901800 vm.stats.vm.v_tfree: 219742493 vm.stats.vm.v_page_size: 4096 vm.stats.vm.v_page_count: 6115784 vm.stats.vm.v_free_reserved: 8013 vm.stats.vm.v_free_target: 130321 vm.stats.vm.v_free_min: 38590 vm.stats.vm.v_free_count: 1178178 vm.stats.vm.v_wire_count: 3905673 vm.stats.vm.v_active_count: 676200 vm.stats.vm.v_inactive_target: 195481 vm.stats.vm.v_inactive_count: 345569 vm.stats.vm.v_cache_count: 9829 vm.stats.vm.v_cache_min: 0 vm.stats.vm.v_cache_max: 0 vm.stats.vm.v_pageout_free_min: 34 vm.stats.vm.v_interrupt_free_min: 2 vm.stats.vm.v_forks: 209120 vm.stats.vm.v_vforks: 15356 vm.stats.vm.v_rforks: 0 vm.stats.vm.v_kthreads: 92 vm.stats.vm.v_forkpages: 9021798 vm.stats.vm.v_vforkpages: 19787317 vm.stats.vm.v_rforkpages: 0 vm.stats.vm.v_kthreadpages: 0 Note: This is on the machine that has the kernel on rev r265164 784466 96 smh 2014-09-05 14:05:44 +0000 (In reply to karl from comment #95) > Note: This is on the machine that has the kernel on rev r265164 And thats the machine that saw the stall yes? Can you also confirm the value for vfs.zfs.arc_free_target 784471 97 karl 2014-09-05 14:23:47 +0000 arc_free_target is set to vm.v_free_target. The ONLY change made to my original code was the one line you requested that added cache pages to the free page count; that effectively causes the code to invade vm.v_free_target by the amount of the cached page count before ARC is pared back. With that in I have a ~50% fail rate running SMB backups to that machine over a Gig-E network due to I/O stalls. The system otherwise appears to be ok in production use but that's a murderous problem in that the I/O stall causes *ALL* I/O on that pool to stall until it clears and thus everything that has open files on that pool and attempts I/O goes into a "D" blocked state. With that one line change OUT I have a ZERO fail rate over SIX MONTHS of doing the exact same thing. I am in the process of recompiling a current -STABLE kernel and world on the test machine, but whether I can reproduce the stalls on that system with this sort of reliability is unknown. I will try, but the lack of success does not mean it won't happen in production, just that I can't successfully reproduce it on that test environment. 784485 98 jhb 2014-09-05 15:10:44 +0000 (In reply to karl from comment #80) > The VM system is quiet when free RAM is above "free_target"; when that is > invaded VM wakes up and starts looking for things it can either demote or > free up. That is the point where contention begins, and arguably where disk > cache should stop growing. If contention continues then ARC must lose this > contention and the reason is simple -- a disk cache invalidation requires > either zero (if the cached item is not requested again) or *one* I/O (if it > is) but a page-out requires *at least* one and perhaps *two* -- one to put > it on the swap file that cannot be avoided and a second one down the road to > recover it if and when necessary. This is incorrect. The pagedaemon does not solely deal with anonymous-backed pages that are written to swap. For non-ZFS, the disk cache lives in the VM cache (there is no separate disk cache), and so cached pages for read(2) and write(2) to non-ZFS go into the "inactive" page pool. It is very common on machines using UFS that pagedaemon will process many pages either discarding clean file-backed pages (no I/Os just as you claimed for ARC) by moving them from inactive to cache, or cleaning them before moving them to cache (one I/O as you noted above). In my experience, the overwhelming number of operations performed by pagedaemon against inactive pages are for file-backed pages and behave as you have described for ARC. When ZFS is used, any ZFS files that are mmap'd are double-copied in order to make read/write coherent with mmap (ZFS read/write operations look for the VM copy of the page before going to ARC). So, with mmap'd files (which is probably common in workloads like databases), ZFS files will have duplicate copies of pages in the "active / inactive / cache" pools that are separate from the ARC copies. I believe that if pagedaemon decides to toss one of these copies, it will get written back into the ARC if it is dirty (so copied into the ARC page, not necessarily written to disk). All that to say that the pagedaemon changes could be related to issues you are seeing, and that you should test those. Certainly with UFS most of the pages pagedaemon deals with are file-backed pages (so "disk cache" in your words), not pages that get written to swap. Even in a ZFS-only system that uses mmap() a non-trivial portion of the pages pagedaemon scans may in fact be file-backed ("disk cache") rather than swap-backed. 784526 99 karl 2014-09-05 17:06:59 +0000 It's all fine and well to argue how it's supposed to work from reading the code but IMHO that's trumped by how it *does* work. The fact is that on the rev I posted up above I can reproduce I/O hangs by running heavy SMB traffic to that box when cache pages are included in the "free" count. With that change (which Steve asked for) reverted, the box rebooted and the ARC cache warmed up, but no other changes of any sort the same SMB job completes without errors and the "pauses" are once again gone as they have been for the last six months dating back to the early days of this PR. NTFS clients are utterly intolerant of long I/O delays and will declare such an I/O failed; the program in question doing the I/O in this case off the Windows machine is Acronis, a rather popular backup tool, and when it gets hit by a "pause" the result is that the backup job errors out. As such perhaps those looking at this issue might contemplate using Samba with a Windows machine mounting the ZFS volume over a high-bandwidth (e.g. Gigabit or better) network connection as a test case. It sure works out well for me in that regard. A directory copy via drag-n-drop of some very large files and directories during a "cd /usr/src/release;make clean;make memstick" on a moderately-sized RAM machine may be sufficient to cause trouble. I can do so pretty much at-will on my production machine as noted above since that system is pretty busy, provided I allow vm.v_free_target to be invaded by the ARC. As soon as I don't allow that to happen the stalls disappear. The base behavior during these "pauses" during writes (if you have multiple pools and the one root is on is not affected -- otherwise you're screwed as you can't activate any image until it clears) is that one or more of the I/O channels associated with a pool has fairly heavy I/O activity on it but the others (that should, given the pool's organization) do not. Since a write cannot return until all the pool devices that must be written to have their I/O completed the observed behavior (I/O "hangs" without any errors being reported) matches what you see with iostat. The triggering event appears to be that paging (even in very small volume!) is initiated due to an attempt to hold ARC cache when the system is under material VM pressure, defined as allowing the ARC to remain sacrosanct beyond the invasion of vm.v_free_target. It does not take much paging during these heavy write I/O conditions to cause it either; I have seen it with only a few hundred blocks on the swap, and the swap is NOT going to ZFS but rather is to a dedicated partition on the boot drive -- so the issue is quite-clearly not contention within ZFS between block I/O and swap activity. In short this looks like a debate between engineering and science. It's certainly a good idea to go find out *why* what you think should happen doesn't and fix whatever that is (science), but in the meantime until you do the person crossing the bridge should be able to get to the other side without going swimming (engineering.) People have been going swimming in this regard since at least FreeBSD-8 with ZFS filesystems and the usual refrain when it happens to someone is that their hardware is broken or they need more RAM. Neither of those assertions has proved up and a lot of unnecessary RAM has likely been bought and disk drives condemned without cause chasing one's tail in this regard, never mind the indictments leveled against various and sundry high-performance disk adapters that appear to have been unfounded as well. The difference in system performance between 99.2% cache hit rates and 99.7% with a doubling of system memory is close to nil but the dollar impact is not especially when a one-line code change could have avoided the expense. Further the fix is not complicated and while there may be a side effect of leaving somewhat more RAM free than would otherwise potentially be the case it's a small side effect even at monstrous RAM configurations (~1.3% of the installed memory.) The alleged "bad side effects" that were claimed to be expected with the original change (specifically, inact pages growing without boundary slamming ARC to minimums) *do not happen* under any workload I or the others testing the original patch have experienced. In any event given a sysctl tunable allows for a more aggressive posture to be tuned should you NOT experience the stalls when vm.v_free_target is invaded. Indeed one line in /etc/rc.local will do that, should someone so choose. The question at the bar is where the *default* should be. If there is a claimed bogon somewhere else in the VM or I/O code that was and/or is the root cause of this behavior (which I certainly buy given the observed behavior) then being more aggressive with ARC is fine at the time that has been validated to be cleared. I'd argue that should mean the community is able to find and peruse an explanation of what the bogon was, when it got into the code (and hopefully why it was thought correct at the time) and the interaction that led to the bad result is explained. Until that verification is complete, however, I argue the correct path of action is to NOT allow the ARC to participate in invading vm.v_free_target. To withhold that actual and functional fix to the problem for the last six months is IMO awfully difficult to defend from an *engineering* perspective. The empirical evidence supports disallowing ARC to result in invasion of vm.v_free at this time and running configured this way has kept the bridge-crossers using it, both myself and others, dry for the last six months. Let's stop dunking people when we know how not to in the present tense. 784527 100 avg 2014-09-05 17:16:55 +0000 Karl, please, just test those pagedaemon fixes. 784532 101 karl 2014-09-05 18:42:28 +0000 I've already said I will test it, and am running that on my test systems now. If I can get it to misbehave I will note it here -- but I will also note that the original "include cache" request *did not* lead to bad results on the test machine but *did* on my production system. It took an overnight for me to find the actions (heavy SMB-based I/O) to cause it, but it occurred. Given this I'm not loading that on my production machine when it's convenient for you since my expectation is that the test will fail. I will load and test it when it's convenient for me and I can quickly revert should I need to on that user-facing machine. However, that leads to the obvious question given the deadline situation that exists for 10.1, and which I believe should be addressed head-on. Simply put why *not* commit the changes with the eviction threshold set to v_free_target? What is the downside of doing so if it turns out that the system can be set more aggressively? A one-line change can certainly be committed later if it turns out to be ok to do so after *rigorous* field testing by far more people than simply myself. Further, that testing can be done *live* without having to recompile anything since the threshold is exposed as a tunable. The claimed expected result from back in March of using v_free_target as the ARC eviction threshold (growth of inactive pages without boundary and a slammed ARC to the minimum) hasn't happened on anyone's machine that has run it. It has happened, however, on some machines and some workloads if the eviction threshold is set *above* v_free_target. I have six months of continuous uptime on the particular production machine with the eviction threshold set at v_free_target and NO bad behavior has occurred. There are also others who are running the same code, set the same way, and none of them have reported unbridled inactive growth or a slammed ARC cache. Finally, it doesn't make sense that it would happen given both pagedaemon and the ARC cache cleanup waking up at the same time (although it *might* lead to slower cleanup by the pagedaemon) and it *has* stopped the stalls. The spreadsheet presented shows that the expected "cost" of that decision is 1.3% of RAM left unallocated on a *terabyte* RAM configuration. The original code in the tree is flat-out broken as the kmem test is wrong. The default "do nothing" decision on not committing the change with the eviction threshold set to v_free_target is to not have ARC evict on other-than-small RAM machines until the VM system goes into desperation paging mode. That's clearly the wrong thing to do and yet that's the "do nothing" result. What my original proposed heuristic does is allow ARC to consume any RAM available so long as v_free_target is not invaded. When it is invaded the ARC is pared back until it's not. This particular signpost is the same place that pagedaemon wakes up. If v_free_target leaves too much RAM unallocated for certain configurations (e.g. as the spreadsheet claims) the correct resolution to that is to change how that value is computed. What your proposed change does is attempt to use the ARC cache as a means of pressuring the VM system to become more aggressive in demoting pages from their respective queues. I get it but what I suspect is going to happen is that when that threshold is approached if an image is activated or an existing process requests a chunk of memory you will be temporarily driven below v_free_min, which is effectively a desperation threshold. I can say with complete certainty that my production system runs like *crap* when its free RAM is down to 150MB, and that which is where v_free_min multiplies out to (38590 on that box.) Beyond my belief that it's a mistake to use the ARC in this manner from a design perspective the empirical evidence to date says that's a bad idea too and not doing it, which was asserted to be expected to lead to bad outcomes has instead proved up over time as having no material downside and *is* effective in eliminating the stalls. 784553 102 karl 2014-09-05 20:50:08 +0000 I can reproduce I/O stalls on the *production* machine within 5 minutes using the default parameters as proposed by simply running an Acronis backup once the cache has warmed up. This is RELIABLY repeatable; I went two-for-two and that was enough for me; the machine has been reverted back to my previous load as it is utterly unusable with this code on it. There is something else nasty going on with the way the ARC code is working with the current patch that goes beyond this as free memory is dramatically higher when the freezes happen (~6GB or so out of 24Gb, which is some 10x what it is with my version of the patch on the previous code rev!) Note that even with arc_free_target manually tuned during runtime to v_free_target it STILL locks. However, you are defining freemem as free_count + cache_count -- so that's not all that surprising since invasion is still taking place. What bothers me even more though is that when I set it manually materially higher it still locked up and the wired page count did not move -- I expected it to. Bluntly this proposed patch *dramatically* screws the pooch; the pattern of I/O and behavior is EXACTLY the same as described in comment #99 and it was utterly trivial to get the lockups to occur. 784603 103 smh 2014-09-06 01:02:32 +0000 (In reply to karl from comment #102) > I can reproduce I/O stalls on the *production* machine within 5 minutes > using the default parameters as proposed by simply running an Acronis backup > once the cache has warmed up. > > This is RELIABLY repeatable; I went two-for-two and that was enough for me; > the machine has been reverted back to my previous load as it is utterly > unusable with this code on it. > > There is something else nasty going on with the way the ARC code is working > with the current patch that goes beyond this as free memory is dramatically > higher when the freezes happen (~6GB or so out of 24Gb, which is some 10x > what it is with my version of the patch on the previous code rev!) > > Note that even with arc_free_target manually tuned during runtime to > v_free_target it STILL locks. However, you are defining freemem as > free_count + cache_count -- so that's not all that surprising since invasion > is still taking place. What bothers me even more though is that when I set > it manually materially higher it still locked up and the wired page count > did not move -- I expected it to. Just to be clear your saying you saw the stalls when we're testing free_count + cache_count < v_free_target but at the same time no paging happened at all? If so this is a very interesting fact as IMO it points the finger not at the VM / pagedaemon but instead at the ARC reclaim process itself. 784642 104 karl 2014-09-06 05:33:02 +0000 Yes, and maybe. I'd agree except that the code changes that were put in didn't just impact arc_reclaim_needed, it also impacted arc_memory_throttle as "freemem" is used there now too -- and if I'm reading the intent of the code correctly it's wrong, although it should be wrong in a way that doesn't screw the system -- maybe. But in any event shouldn't that test be the same as in arc_reclaim_needed? In addition there is a VM system change involved as well. So which of the three is responsible for the bad behavior? And just to make sure nobody mistakes the issue here -- it is bad enough that the machine becomes *completely unusable* as soon as any sort of heavy SMB-based write I/O (e.g. Samba) hits it, locking up the pool being written to for 30+ seconds at a time repeatedly and hanging any process that happens to attempt to I/O to it. 784838 105 smh 2014-09-06 16:35:59 +0000 (In reply to karl from comment #104) > Yes, and maybe. > > I'd agree except that the code changes that were put in didn't just impact > arc_reclaim_needed, it also impacted arc_memory_throttle as "freemem" is > used there now too -- and if I'm reading the intent of the code correctly > it's wrong, although it should be wrong in a way that doesn't screw the > system -- maybe. But in any event shouldn't that test be the same as in > arc_reclaim_needed? The changes to arc_memory_throttle to use freemem instead of vm_cnt.v_free_count + vm_cnt.v_cache_count are difference eliminations and have no functional effect as freemem = vm_cnt.v_free_count + vm_cnt.v_cache_count. > In addition there is a VM system change involved as well. If your referring to the split of pagedaemon init then that's just to allow for correct startup ordering, so will have no effect on this behaviour. > So which of the three is responsible for the bad behaviour? Assuming I understood you correctly there's actually only one change in play and that's the point at which ARC triggers reclaim. > And just to make sure nobody mistakes the issue here -- it is bad > enough that the machine becomes *completely unusable* as soon as > any sort of heavy SMB-based write I/O (e.g. Samba) hits it, locking > up the pool being written to for 30+ seconds at a time repeatedly > and hanging any process that happens to attempt to I/O to it. In order to narrow down what is causing this I've attached an updated stable/10 patch and some dtrace scripts which will: 1. Allow you to exclude v_cache_count from the arc_reclaim_needed test using: sysctl vfs.zfs.arc_reclaim_cache_free=0 2. Use dtrace to investigate ARC evicts. 784839 106 146946 smh 2014-09-06 16:38:13 +0000 Created attachment 146946 arc reclaim refactor (against stable/10) Add some test DTRACE probes and sysctl 784840 107 146947 smh 2014-09-06 16:38:59 +0000 Created attachment 146947 ARC evict dtrace script 784841 108 146948 smh 2014-09-06 16:39:27 +0000 Created attachment 146948 ARC reap dtrace script 784842 109 146949 smh 2014-09-06 16:39:53 +0000 Created attachment 146949 ARC reclaim dtrace script 784845 110 smh 2014-09-06 16:53:05 +0000 With the above changes / scripts I'd like to try and identify the nature of the behaviour that's causing the stalls. Details on the scripts: * arc-evict.d - will show you want and how much is being evicted from ARC. * arc-reap.d - will show you how long arc_reap_now calls are taking and when arc_shrink is called. * arc-reclaim.d - will show you what the cause for for arc_reclaim_needed returning true is. Its important to test these with a full recent version of stable/10 I'm currently testing with r271116. If you get any strange issues with dtrace then you may need to do a second build of kernel and world once an initial version of world has been installed. 784849 111 karl 2014-09-06 17:13:31 +0000 (In reply to Steven Hartland from comment #105) > (In reply to karl from comment #104) > > Yes, and maybe. > > > > I'd agree except that the code changes that were put in didn't just impact > > arc_reclaim_needed, it also impacted arc_memory_throttle as "freemem" is > > used there now too -- and if I'm reading the intent of the code correctly > > it's wrong, although it should be wrong in a way that doesn't screw the > > system -- maybe. But in any event shouldn't that test be the same as in > > arc_reclaim_needed? > > The changes to arc_memory_throttle to use freemem instead of > vm_cnt.v_free_count + vm_cnt.v_cache_count are difference eliminations > and have no functional effect as freemem = vm_cnt.v_free_count + > vm_cnt.v_cache_count. Ah, but the test is not the same; that is, the throttle can be invoked even though eviction is not taking place, and yet the comments in the code strongly imply that throttling should not happen UNLESS eviction is taking place. Should not the test be the same? > > In addition there is a VM system change involved as well. > > If your referring to the split of pagedaemon init then that's just > to allow for correct startup ordering, so will have no effect on this > behaviour. No, I'm referring to the alleged cleanups that led to this request for slamming the ARC's eviction threshold to where paging occurs instead of where the system declares that it is under (some) memory pressure. > > > So which of the three is responsible for the bad behaviour? > > Assuming I understood you correctly there's actually only one change in > play and that's the point at which ARC triggers reclaim. No. There are three (known) changes relative to the code running on the production machine which does not exhibit the problem. > In order to narrow down what is causing this I've attached an > updated stable/10 patch and some dtrace scripts which will: > 1. Allow you to exclude v_cache_count from the arc_reclaim_needed test using: > sysctl vfs.zfs.arc_reclaim_cache_free=0 > 2. Use dtrace to investigate ARC evicts. My current path is to attempt to provoke the bad behavior on my test system. I'm *not* pleased with the outcome of what I was asked to test yesterday given the assertions that it was "more correct" than my original, working and fully-functional patch. Please understand -- I have working code now, and will continue to have working code. These attempts to "improve" it which were requested in fact led to that system taking a significant and outrageously-invasive (from the user perspective) hit *in production.* That's not going to happen again and I am certainly not going to provoke said bad behavior on said production, internet-facing machine so I can diddle with dtrace *on a live system serving users* while said users all go swimming instead of crossing the bridge. I will continue efforts to reproduce the behavior on my test machine as time permits. 784900 112 smh 2014-09-06 19:47:52 +0000 (In reply to karl from comment #111) > (In reply to Steven Hartland from comment #105) > > (In reply to karl from comment #104) > > > Yes, and maybe. > > > > > > I'd agree except that the code changes that were put in didn't just impact > > > arc_reclaim_needed, it also impacted arc_memory_throttle as "freemem" is > > > used there now too -- and if I'm reading the intent of the code correctly > > > it's wrong, although it should be wrong in a way that doesn't screw the > > > system -- maybe. But in any event shouldn't that test be the same as in > > > arc_reclaim_needed? > > > > The changes to arc_memory_throttle to use freemem instead of > > vm_cnt.v_free_count + vm_cnt.v_cache_count are difference eliminations > > and have no functional effect as freemem = vm_cnt.v_free_count + > > vm_cnt.v_cache_count. > > Ah, but the test is not the same; that is, the throttle can be invoked even > though eviction is not taking place, and yet the comments in the code > strongly imply that throttling should not happen UNLESS eviction is taking > place. The value is identical it what it was so I don't follow what your trying to say I'm afraid. > Should not the test be the same? > > > > In addition there is a VM system change involved as well. > > > > If your referring to the split of pagedaemon init then that's just > > to allow for correct startup ordering, so will have no effect on this > > behaviour. > > No, I'm referring to the alleged cleanups that led to this request for > slamming the ARC's eviction threshold to where paging occurs instead of > where the system declares that it is under (some) memory pressure. That's nothing to do with VM, its an ARC change, which is why I provide the ability to switch methods in the latest version, so you can test with each option without reboots. > > > So which of the three is responsible for the bad behaviour? > > > > Assuming I understood you correctly there's actually only one change in > > play and that's the point at which ARC triggers reclaim. > > No. There are three (known) changes relative to the code running on the > production machine which does not exhibit the problem. I don't know what changes your referring to then I'm afraid. > > In order to narrow down what is causing this I've attached an > > updated stable/10 patch and some dtrace scripts which will: > > 1. Allow you to exclude v_cache_count from the arc_reclaim_needed test using: > > sysctl vfs.zfs.arc_reclaim_cache_free=0 > > 2. Use dtrace to investigate ARC evicts. > > My current path is to attempt to provoke the bad behavior on my test system. > I'm *not* pleased with the outcome of what I was asked to test yesterday > given the assertions that it was "more correct" than my original, working > and fully-functional patch. > > Please understand -- I have working code now, and will continue to have > working code. These attempts to "improve" it which were requested in fact > led to that system taking a significant and outrageously-invasive (from the > user perspective) hit *in production.* > > That's not going to happen again and I am certainly not going to provoke > said bad behavior on said production, internet-facing machine so I can > diddle with dtrace *on a live system serving users* while said users all go > swimming instead of crossing the bridge. Appreciated, but in order to get to the bottom of the issue I wanted to provide you some tools that should help with that. From what you've said the issue presents as a 30 second stall, so if you cant create a test scenario the updates will now allow you to switch between the bad and good values instantly hence able to capture information from a single stall with no reboots required. 784959 113 karl 2014-09-07 03:24:37 +0000 I went back and looked at the original unaltered (and older) arc.c file; you're correct, the throttle code is unchanged. I'm going to continue trying to reproduce the problem on the test machine, but I'm not loading it again on the production system until I understand fully why the behavior changed when it should not have (specifically, when I cranked up the arc_free_target well beyond the VM's free target value the stalls did NOT immediately stop -- they should have.) That will mean being able to reproduce the problem under test. The issue presents itself as an I/O stall of sufficient duration to error out a SMB file operation (via Samba) on a Windows machine running Acronis to the ZFS volume, and some of the stalls are WELL beyond 30 seconds -- we're talking about a couple of minutes in many cases, and any I/O to a ZFS disk blocks during that time. There may be multiple sequential stalls occurring; I've not been able to determine that with any sort of reliability. No errors are logged to the console or elsewhere during that time or when the stall ends. I'm not entirely certain whether it's local to the pool that the original I/O that blocked was directed at -- I don't think it is, but it's very hard to be certain as one wrong move and your shell session blocks when you're trying to look around while it's happening. If systat is open it typically shows a pinned drive for percentage in use at 100%, but not all of them for a given pool, but whether that's a true state being reported or it's a function of systat being blocked is unknown. 784961 114 karl 2014-09-07 03:39:48 +0000 One other note -- there's something else going on too with your patch, and it's not good. 1 users Load 0.00 0.00 0.00 Sep 6 22:26 Mem:KB REAL VIRTUAL VN PAGER SWAP PAGER Tot Share Tot Share Free in out in out Act 56044 22988 862556 36132 5929704 count All 2592072 25680 937452 87808 pages Proc: Interrupts r p d s w Csw Trp Sys Int Sof Flt ioflt 6858 total 33 4572 17k 72k 1778 17k cow atkbd0 1 17018 zfod uhci0 16 25.0%Sys 0.0%Intr 0.0%User 0.0%Nice 75.0%Idle ozfod ehci0 uhci | | | | | | | | | | %ozfod uhci1 21 ============= daefr twa0 32 dtbuf prcfr cpu0:timer Namei Name-cache Dir-cache 281984 desvn totfr mps0 256 Calls hits % hits % 120767 numvn react 762 em0:rx 0 8 8 100 68849 frevn pdwak 1016 em0:tx 0 pdpgs em0:link Disks da0 da1 da2 da3 da4 da5 da6 intrn cpu1:timer KB/t 0.00 0.00 0.00 0.00 0.00 0.00 0.00 4847604 wire cpu9:timer tps 0 0 0 0 0 0 0 6276 act cpu7:timer MB/s 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1416036 inact cpu10:time %busy 0 0 0 0 0 0 0 cache cpu5:timer 5929788 free cpu12:time buf cpu4:timer cpu15:time 4826 cpu2:timer cpu13:time cpu6:timer cpu14:time cpu3:timer 254 cpu11:time cpu8:timer That's the test machine. It's idle right now. Note the huge amount of free memory. $ zfs-stats -A ------------------------------------------------------------------------ ZFS Subsystem Report Sat Sep 6 22:27:29 2014 ------------------------------------------------------------------------ ARC Summary: (HEALTHY) Memory Throttle Count: 0 ARC Misc: Deleted: 651.78k Recycle Misses: 162.27k Mutex Misses: 40 Evict Skips: 692.02k ARC Size: 29.78% 3.17 GiB Target Size: (Adaptive) 29.81% 3.17 GiB Min Size (Hard Limit): 12.50% 1.33 GiB Max Size (High Water): 8:1 10.63 GiB ARC Size Breakdown: Recently Used Cache Size: 51.28% 1.63 GiB Frequently Used Cache Size: 48.72% 1.54 GiB ARC Hash Breakdown: Elements Max: 452.56k Elements Current: 84.98% 384.56k Collisions: 339.78k Chain Max: 5 Chains: 33.10k ------------------------------------------------------------------------ That ain't right. ARC was around 8Gb when I left this afternoon immediately after running a big file copy and a buildworld at the same time in an (unsuccessful) attempt to get it to lock up. This sort of slam-down is exactly, in fact, what your patch was allegedly supposed to avoid. Needless to say I don't think it will be possible to get it to lock up as long as that's the state it's going to remain in. Parameters are at defaults (intentionally) since I was trying to provoke the problem this morning. $ sysctl -a|grep free_target vm.v_free_target: 65013 vm.stats.vm.v_free_target: 65013 vfs.zfs.arc_free_target: 21186 This is a 12Gb RAM machine, dual-CPU Xeon box (nominally 8-way SMP plus Hyperthreading.) I will bring the tree up to the current level and re-apply the patch but at some point I need a stable reference. Whatever it's doing now clearly isn't, and when it is behaving this way I would not expect to be able to lock it up no matter what I do, but that's very undesirable behavior out of the ARC in the opposite direction! 785105 115 karl 2014-09-07 15:30:59 +0000 And with the test system under heavy I/O load -- note the free memory. 5 users Load 1.18 1.55 1.19 Sep 7 10:28 Mem:KB REAL VIRTUAL VN PAGER SWAP PAGER Tot Share Tot Share Free in out in out Act 103208 17908 1699800 26648 2216268 count All 9107864 22860 1784888 88044 pages Proc: Interrupts r p d s w Csw Trp Sys Int Sof Flt ioflt 20074 total 1 52 75k 1476 47k 15k 240 2 cow atkbd0 1 2 zfod 41 uhci0 16 4.4%Sys 2.0%Intr 0.2%User 0.0%Nice 93.4%Idle ozfod ehci0 uhci | | | | | | | | | | %ozfod uhci1 21 ==+ daefr 33 twa0 32 dtbuf 2 prcfr 308 cpu0:timer Namei Name-cache Dir-cache 281984 desvn 6 totfr 2136 mps0 256 Calls hits % hits % 16137 numvn react 6471 em0:rx 0 3 3 100 9313 frevn pdwak 6462 em0:tx 0 54 pdpgs em0:link Disks da0 da1 da2 da3 da4 da5 da6 intrn 147 cpu1:timer KB/t 93.14 92.89 93.20 92.86 10.46 10.37 0.00 9710040 wire 1057 cpu12:time tps 539 543 541 543 16 17 0 131684 act 220 cpu3:timer MB/s 49.05 49.24 49.24 49.24 0.17 0.17 0.00 141712 inact 104 cpu10:time %busy 80 57 56 56 14 15 0 33880 cache 157 cpu7:timer 2182388 free 1044 cpu13:time buf 318 cpu6:timer 99 cpu9:timer 131 cpu4:timer 110 cpu15:time 235 cpu5:timer 127 cpu14:time 164 cpu2:timer 606 cpu11:time 104 cpu8:timer root@dbms2:/home/karl # zfs-stats -A ------------------------------------------------------------------------ ZFS Subsystem Report Sun Sep 7 10:29:37 2014 ------------------------------------------------------------------------ ARC Summary: (HEALTHY) Memory Throttle Count: 0 ARC Misc: Deleted: 824.50k Recycle Misses: 115.32k Mutex Misses: 32 Evict Skips: 19.64m ARC Size: 73.94% 7.86 GiB Target Size: (Adaptive) 73.95% 7.86 GiB Min Size (Hard Limit): 12.50% 1.33 GiB Max Size (High Water): 8:1 10.63 GiB ARC Size Breakdown: Recently Used Cache Size: 93.75% 7.37 GiB Frequently Used Cache Size: 6.25% 503.29 MiB ARC Hash Breakdown: Elements Max: 137.09k Elements Current: 98.80% 135.44k Collisions: 54.28k Chain Max: 3 Chains: 4.27k ------------------------------------------------------------------------ Throttled down from max size materially -- but.... why, given the alleged intent of the current patch above and no memory pressure? Something's not right here. In addition the dtrace scripts do not compile against the current patch and source unchanged. 785107 116 smh 2014-09-07 15:40:37 +0000 (In reply to karl from comment #115) > > In addition the dtrace scripts do not compile against the current patch and > source unchanged. Anyone in particular? I can see the arc-reclaim.d has to addition trace points not in the stable/10 code, simply comment out the two lines: /* vm:::vm-lowmem_cache, vm:::vm-lowmem_scan, */ 785108 117 147014 smh 2014-09-07 15:50:26 +0000 Created attachment 147014 VM lowmem probe 785110 118 smh 2014-09-07 16:14:18 +0000 (In reply to karl from comment #115) > ARC Size: 73.94% 7.86 GiB > Target Size: (Adaptive) 73.95% 7.86 GiB > Min Size (Hard Limit): 12.50% 1.33 GiB > Max Size (High Water): 8:1 10.63 GiB ... > > ------------------------------------------------------------------------ > > Throttled down from max size materially -- but.... why, given the alleged > intent of the current patch above and no memory pressure? Something's not > right here. Its not 100% obvious, but throttling is an over time thing, so it will happen if there "has" been pressure. After that point it will slowly expand backup to max assuming no pressure. 785114 119 karl 2014-09-07 16:44:43 +0000 But there never was pressure. That's the point -- the system was booted with the latest svn update run, built and installed, then the backup test was run. During the backup run the ARC target was pared down even though ~20% of installed RAM remained free. 785155 120 smh 2014-09-07 18:23:01 +0000 (In reply to karl from comment #119) > But there never was pressure. That's the point -- the system was booted > with the latest svn update run, built and installed, then the backup test > was run. During the backup run the ARC target was pared down even though > ~20% of installed RAM remained free. While you might not think there was, the only way for ARC to action a shrink is if it sees VM pressure. There are a number of triggers for this but one way or another that's what happened. 785159 121 karl 2014-09-07 18:30:47 +0000 Understood -- my point is that the "pressure" point that was experienced isn't where the changes that were put in allegedly placed it, and that at no time does it appear that the VM system actually thought it was under pressure (that is, free space never went below vm.free_target.) 785362 122 147068 smh 2014-09-08 15:25:11 +0000 Created attachment 147068 ARC reclaim refactor (against stable/10) Updated default zfs_arc_free_target to (vm_pageout_wakeup_thresh / 2) * 3; Added more dtrace probes Fixed missing include causing i386 path to still be take on stable version. 785364 123 147069 smh 2014-09-08 15:27:29 +0000 Created attachment 147069 ARC resize dtrace script 785365 124 147070 smh 2014-09-08 15:29:46 +0000 Created attachment 147070 ARC reclaim refactor (against head) Updated default zfs_arc_free_target to (vm_pageout_wakeup_thresh / 2) * 3; Added more dtrace probes 785368 125 karl 2014-09-08 15:41:06 +0000 That setting for arc_free_target still produces degenerate I/O and RAM behavior on my test system. Setting it to vm_free_target during runtime greatly lessens (but does NOT completely eliminate) said behavior. The degenerate behavior exhibits as wildly disparate I/O rates (in TPS, MB/S and %busy) to the members of a raidz2 pool (which should never happen under write-heavy loads) that are coordinated with wildly-oscillating free RAM; as much as 1.5Gb on a 12G system. What appears to be happening is that actual I/O is getting blocked by something (memory allocation?); if you get an image activation and/or RAM demand during one of those cycles I would expect a full-on freeze because if you cannot complete all the I/Os required on a raidz2 pool to complete the write safely you will block until you can. 785372 126 karl 2014-09-08 16:03:14 +0000 Shutting off vfs.zfs.arc_reclaim_cache_free further reduces the oscillations - possibly to a large enough degree that the system would be stable under heavy production loads with random (e.g. user-created) image activation and RAM allocation on top of the synthetics. 785401 127 karl 2014-09-08 17:33:58 +0000 OK, from the testing that Steve has requested (along with avg) here is the test environment and my results. a. Configuration has 12Gb RAM and dual Xeon CPUs (8-way nominal SMP) b. There are two pools on separate disk adapters, both running as JBOD with no on-board cache or similar indirections. The boot pool is a 2-way mirror and the data pool on which the pressure is applied is a 4-device raidz2. The filesystem on the second pool has lz4 compression enabled. Swap file is on a dedicated disk partition (not on zfs) c. A small program is used to dirty and lock up 4gb of wired RAM to simulate the buffering memory used by a moderately-sized Postgres database. d. A second small program is run that opens a file on the raidz2 pool's filesystem with O_SYNC and then repeatedly lseek()s to a random location within a 20Gb file locus and writes 512 bytes of random data there. This simulates a write-heavy database I/O load and heavily stresses the synchronous commit mechanism. e. Finally, I use Acronis to create heavy sequential write I/O pressure over Gig-E ethernet link by running a 200Gb backup to the data pool. With defaults once the cache warms up I observe pathological behavior in the form of severe oscillations in both free RAM and I/O rates. Specifically, free RAM oscillates between less than 200Mb and over 1.5Gb free, and at the same time I see oscillations of more than 10:1 between I/O spindles in both tps and MB/Sec, with one spindle typically pinned on busy% while the others oscillate between being approximately as busy (normal) and dropping to single-digit utilizations and double-digit tps (grossly abnormal.) Granularity of the systat display does not allow me to determine exactly which unlocking event comes first but it appears that when I/O rates are balanced free RAM is rapidly depleted and then rates diverge dramatically. Some paging activity is noted, but not a gross amount (10-20Mb of total page space consumed.) No errors are logged during any of the tests. These oscillations can be reduced dramatically by increasing arc_free_target to vm_free_target. They are reduced further by excluding cache pages from the free computation, however, that reduction is relatively modest. The mitigating factor here is that under this test there are few cache pages in the first place; for a system with more of them in normal operation the impact would likely be much larger. Erratta: After extended testing and shutting down all involved processes I have roughly a gigabyte of unaccounted for wired memory I cannot trace that was not present at boot time; zfs-stats -A shows only ~40MB consumed (concurs with vmstat -m.) I do not have a means of identifying the source of this wired allocation but it is somewhat-concerning as it may indicate a memory leak somewhere in the code. All of the RAM allocated by my wired-ram pressure program was released when it exited. Results from the requested testing: 1. Allowing vm_free_target to be invaded *to any degree* by the ARC causes pathological behavior within both the I/O and memory systems. Specifically, it results in I/O and free RAM oscillations that, if they coincide with natural RAM pressure (e.g. image activation due to a user request, etc) can and do lead to stalls, and it causes paging activity that arguably should not, given the actual RAM and system pressure, take place. 2. Evicting ARC at vm_free_target and NOT including cache memory in the free computation, dramatically reduces both the I/O throughput oscillations on the pool(s) to which I/O is being done (from more than 10:1 deviations to ~2:1 or so maximum) *and* reduces free RAM oscillations as well (by a factor of about four.) It does *not*, however, eliminate either condition entirely and the remaining oscillations are statistically significant. Given the steady-state workload being imposed on the system this is unexpected behavior. 3. Evicting ARC *above* vm_free_target does not cause problems in my test system but *was* reported in earlier testing of my original patch to do so for some other people's workloads, and as such that default was removed (the original "additional percentage" reservation.) Doing so, however, *did* provide further statistically-significant improvements in I/O and RAM stability. 4. These observations match what I previously observed in earlier versions of 10-STABLE and led to the patch in comment #10. 5. The pagedaemon commits to 10-STABLE between when I developed the original patch and today that avg believed would address the issue *do not* change in a detectable fashion the pathological behavior under test conditions. Comments and recommendations: The original Illumos code stays *well* clear of attempting to pressure the VM system for other configurations (e.g. Solaris, etc.) Attempting to use the ARC as a means of pressuring the pagedaemon is easily shown to result in pathological behavior of both the memory and I/O subsystems and, for some workloads, will result in unacceptable performance degradation that manifests either in poor I/O performance at best or, under certain conditions that are difficult to reproduce in a synthetic test (but not hard for me to reproduce in production) outright system stalls. Steve appears to have identified and fixed additional issues with code includes that resulted in an inappropriate computation for non-i386 systems in some cases. These should, of course, be included in any commit/MFC. Against the current patch the configuration that produces the best behavior in test without notable side effects come with arc_free_target = vm_free_target and arc_reclaim_cache_free = 0, neither of which is the current default. This is effectively the same heuristic for ARC behavior as found in my comment #10. I therefore recommend arc_free_target = vm_free_target and arc_reclaim_cache_free = 0 as defaults as while this does not completely resolve the oscillation problem it minimizes it without resulting in undesirable side effects such as the unbridled growth of the inact page pool or slamming the ARC to minimums over time. I further recommend attempting to identify a means of protecting the RAM allocation necessary to complete ZFS I/O so that it does not block under even extreme RAM pressure but I recognize that may not be possible given underlying VM system design. Illumos appears to have recognized this risk to performance in the original code by how they intentionally remained well away from low-memory conditions. 786353 128 147265 karl 2014-09-13 05:25:58 +0000 Created attachment 147265 Patch to correct ZFS "freeze" ram contention problem (apply after Steve's latest 10-Stable patch above) After much additional back and forth with Steve I believe I have identified the reason for #2 in my reported results and have developed a patch to address it. What we are doing right now is essentially violence served upon the ZFS code in an attempt to force it to pressure the VM system to reclaim memory that can then be used for ARC. While setting arc_free_target = vm_free_target helps this situation, and in fact in my testing doubling both arc_free_target and vm_free_target helped *even more*, it did not result in a "complete" fix. I now understand why. In short the dirty memory that ZFS internally allocates for writes can be enough to drive the system into aggressive paging, even when it is trying to aggressively reclaim ARC. The problem occurs when large I/O requirements "stack up" before the ARC can evict which forces free memory below the paging threshold. This in turn causes the ZFS I/O system to block on paging (that is, it is blocked waiting for the VM system to give it memory and the VM system must page to do so), which is a pathological condition that should never exist. I can re-create this behavior "at will". At present "as delivered" (with or without Steve's patch) the code will allow up to 10% of system RAM to be used for dirty I/Os or 4GB, which ever is less. The problem is that on a ~12GB system that is 1.2GB of RAM, and that exceeds the difference between free_target and the paging threshold (by a *lot*!) A similar problem exists for other configurations; at 16GB the difference between free_min and free_target (by default) is ~250MB but 10% of the installed memory is 1.6GB, or roughly SIX TIMES the margin available. If you allow the ARC to invade beyond free_target then the problem gets worse for obvious reasons. This is why setting it to free_target helps, and in fact why when I *doubled* free_target it helped even more -- but did not completely eliminate the pathology, and I was still able to force paging to occur by simply loading up on big write I/Os. I propose that I now have a fix instead of a workaround. Note that for VERY large RAM configurations (~250GB+) the maximum dirty buffer allocation (4GB) is small enough that you will not invade the paging threshold. In addition if you are not write I/O bound in the first place you won't run into the problem since the system never builds the write queue depth and thus you don't get bit by this at all. But if you throw large write I/Os at the system at a rate that exceeds what your disks can actually perform at there is a decent probability of forcing the VM system into a desperation swap condition which destroys performance and produces the "hangs." *Any* workload that produces large write I/O requests that exceed the disk performance available is potentially subject to this behavior to some degree, and the more large write I/O stress you put on the system the more-likely you are to run into it. Workloads that mix sync I/Os on the same spindles as large async write I/Os are especially bad because the sync I/Os slow total throughput available dramatically. In addition during a resilver, especially on a raidz(x) volume where I/O performance is materially impaired (it is often cut by anywhere between 50-60% during that operation) you're begging for trouble for the same reason. Steve pointed me at a blog describing some of the changes in the I/O subsystem in openzfs along with how the code handles dirty pages internally and, with some code-perusing the missing piece fell into place. The solution I have come up with is to add dynamic sizing of the dirty buffer pool to the code that checks for the need to evict ARC. By dynamically limiting the outstanding dirty I/O RAM demand to the margin between the current free memory and the system's paging threshold even ruinously nasty I/O backlogs no longer cause the system to page and you no longer get ZFS I/O threads in a blocking state. I can now run on my test system with an intentionally faulted and resilvering raidz2 pool, dramatically cutting the I/O capacity of the system, while hammering the system with I/O demand at well beyond 300% of what it can deliver. It remains stable over more than an hour of that sustained treatment; without this patch the SMB-based copies fail within a couple of minutes and the system becomes unresponsive for upwards of a minute at a time. The patch is attached above; it applies against Steve's refactor for Stable-10 pulled as of Friday morning. Please consider testing it if you have an interest in this issue. Thanks. 786401 129 karl 2014-09-13 15:16:33 +0000 The patch I added last night to this thread has now been validated against the older 10.0-STABLE code build I am running on my production system (with my original changes to arc.c.) This eliminates the pagedaemon changes avg proposed as effacious as being effective since they are not in the revision of 10.0-STABLE in question (r265164M) I am now attempting to roll forward the production machine to 10.1-PRE since it appears, even under severe stress, that the resolution is effective on both r265164 and r271435. 786403 130 smh 2014-09-13 16:10:02 +0000 Dynamically adjusting zfs_dirty_data_max could caus a panic in dmu_tx_delay due to divide by zero. 786407 131 147274 karl 2014-09-13 16:33:04 +0000 Created attachment 147274 See comment -- fix potential divide-by-zero panic That's easily fixed (divide by zero risk) -- new patch that does so attached. This should apply against stable/10 from zero (this patch incorporates Steve's patch from 2014-09-08 and does NOT require it be applied first.) 786408 132 147275 karl 2014-09-13 16:38:12 +0000 Created attachment 147275 Replace previous patch -- picked up wrong copy (extra parenthesis) Comment above applies; picked up the wrong file when attaching. 786409 133 147276 karl 2014-09-13 16:41:50 +0000 Created attachment 147276 Argh - didn't include all of Steve's other changes -- yet another try :-) Include all of Steve's previous other changes to Stable-10. Sorry about that. 786410 134 karl 2014-09-13 16:44:56 +0000 Hold on a second -- one more time (wrong copy AGAIN) :-) 786419 135 karl 2014-09-13 17:55:05 +0000 Steve has pointed out a potential (very small, but possible) window where a divide-by-zero could occur. Working on that -- careful with that axe if you apply the previous patch. :-) 786468 136 147286 karl 2014-09-13 20:34:10 +0000 Created attachment 147286 Candidate Fix (supersedes previous) Move dirty_max resize into dmu_tx.c in the function dmu_tx_assign. This places it in front of the thread mutex which should prevent the possibility (small, but present) of a divide-by-zero identified by Steve. Verified to apply against r271435, builds cleanly and survived two "hell tests", including extreme I/O stress during a raidz2 resilver, that have killed the test machine repeatedly in the past. It is currently under a fairly extreme soak test and has exhibited no problems at all. Note that this patch includes Steve's refactor against 10-STABLE; Comments from others are appreciated. 786904 137 junchoon 2014-09-15 12:46:32 +0000 (In reply to karl from comment #136) Working with no problem for me. Thanks. stable/10 r271481 amd64. But one strange thing. At the time previous Steven's patch was uploaded, I accidentally forgotten to apply it ('patch -R' for previously applied one, 'patch -C' for integriety check, and missed 'patch'), but observed no thrashing behavior with the kernel. (I noticed it by absense of vfs.zfs.arc_free_target sysctl.) As I applied the patch and rebuilt kernel right after I noticed that, my only stress test without patch was rebuilding kernel. At least, when I first applied Karl's patch (Mar.26, 2014), severe thrashing behavior was observed with vanilla GENERIC kernel while memory-intensive jobs, such as linking kernel, linking www/chromium etc., and Karl's patch helped. I haven't determined which change (maybe in sys/vm) helped, but I haven't observed any negative influence with latest Karl's patch. By the way, I think this bug 187594 should be Release Blocker (Show Stopper) issue for 10.1, but not currently listed in https://www.freebsd.org/releases/10.1R/todo.html. Shouldn't this listed there? 787105 138 karl 2014-09-16 18:41:54 +0000 No problems noted with the latest on either test or production systems. The production system was subjected to ridiculous levels of abuse yesterday with the latest patch in due to a burst of activity and it showed no distress. As an aside Steve MFC'd a fix for a fairly-serious but unrelated problem that IS evident in recent 10.x that I was chasing down on the Illumos list; the symptom is that a resilver can either restart repeatedly or never complete. The reason was a bogon in the code related to ZFS attempting to use TRIM on drives that don't support it -- this caused the resilver to be queued for a restart due to the "error" returned from the TRIM attempt. Steve reports it's fixed as of r271683. There was a patch committed some time ago to address this but MFCing it apparently slipped through the cracks. 787111 139 jhay 2014-09-16 19:40:00 +0000 I found this after I saw the email from Karl. I upgraded to 10-stable svn 271611 and applied the patch mention in comment 136. And what a difference. :-) My machine reacts when I type or click on another window. Previously I often had to wait for 30+ seconds. For the record, the machine has 4G RAM and boot from zfs. It is my desktop but builds snapshots at night. 787522 140 147459 karl 2014-09-19 01:45:02 +0000 Created attachment 147459 Replaces previous; results of further work with Steve From findings and further effort; credit to Steve as well as plenty of work has gone into this across the board. 1. The UMA allocator is, for "pedestrian" system configurations, *badly* broken both in grabbing ridiculously large chunks of RAM and not releasing them when it should. This patch turns it off; MFCing that back on appears to have been a serious mistake as shutting it off stops a lot of the pathology that appeared to be coming from the ZFS buffer management code. Those with *very* large RAM configurations where unannounced 2GB "grabs" of RAM and significant chunks of memory sitting around in the wired state for periods of time even though allegedly released do not severely impact performance may have a different view. 2. With the crazy RAM grab problems gone resizing of the write buffers is no longer necessary. Remove that code. 3. Set arc_free_target to the paging threshold plus of the difference between the VM system's free target and the paging threshold. There is apparently a belief in some quarters that it should be at the paging threshold. On both a 12Gb and 4Gb configuration setting it there in my environment produces materially worse performance as well as swapping that appears to be unnecessary; the 12Gb configuration also produces fairly-severe free RAM oscillations with it set there that go away with where I have configured it. Free free to try it both ways. Should apply against 10-STABLE r271838 and similar, supersedes previous. Differs materially from Steve's latest refactor only in turning off the uma allocator and where the default free_target is set. Note that if you have actual hard disks (and not SSDs) you want to be either on 271683 or later, or, if not, turn off TRIM in your /boot/loader.conf with vfs.zfs.trim_enabled=0. See comment #138. 787648 141 gibbs 2014-09-20 06:39:02 +0000 Can you provide more information about the measurements you performed to conclude that UMA is interacting poorly with ZFS? Disabling UMA significantly increases CPU utilization in ZFS. On some workloads (SSDs and 8K record size) using UMA doubles ZFS's performance, so it would be better to fix UMA (or ZFS's use of UMA), then to just turn it off. 787714 142 karl 2014-09-20 15:06:20 +0000 I'm working on that (fixing the way ZFS interacts with the UMA allocation system.) I have taken Steve's refactor and continued work, as I can easily produce workloads here that cause either system stalls or (in a couple of cases I can produce on occasion) kernel panics due to outright RAM exhaustion with the parameters set where Steve and, apparently the rest of the core team wants them. ZFS' code was originally designed to remain well beyond the paging threshold in RAM consumption. If you look at the original ARC code and how it determines sizing strategy this is apparent both in the comments and the code itself. Unfortunately this is a problem on FreeBSD because the VM system is designed to essentially sleep and do nothing until available system memory drops below vm.v.free_target. So if you use ZFS on FreeBSD, and there was no change made to that strategy, over time inactive and cache pages would crowd out the ARC cache until it dropped to the minimum. This is unacceptable for obvious reasons so on FreeBSD the the code is (ab)used to pressure the VM system by intentionally invading the vm.v.free_target threshold, causing pagedaemon to wake up and clean up the kitchen floor of all the old McDonalds' hamburger wrappers. There is in fact apparently a belief in the core team that the ARC's eviction code should remain asleep until RAM reaches the vm.pageout_wakeup_thresh barrier, effectively using ARC to force the system to dance on the edge of the system's hard paging threshold. This is, in my opinion, gross violence upon the original intent of the ZFS code because causing the system to swap in preference to keeping a (slightly) larger disk cache is IMHO crazy, but this is the where my recent work has focused at their request. I've acceded to it for testing purposes (although I'll never run *my* systems configured there, and the patches I've got here don't have it set there) because if I can get the system to be stable with it set at that value it will run (much) better with what I believe is a more-sane choice for that parameter (vfs.zfs.arc_free_target), and that I (and everyone else) can tune easily. UMA is much faster but it gets its speed in part by "cheating." That is, it doesn't actually return memory to the system when it's told to free memory right away; the overhead is deferred and taken "at convenient (or necessary) times" instead of for each allocation and release. It also has the characteristic of grabbing quite-large chunks of RAM at impressive rates of speed for its internal use within its internal bucketing system. The lazy release, while good for performance, can get you in a lot of trouble if you're dancing near the limits of RAM exhaustion and before that release happens an allocation is requested that cannot be filled with the existing free buckets in the UMA and thus a further actual RAM allocation is required. As written ZFS currently calls the UMA reap routines in the arc maintenance thread. This, in a heavy I/O load environment with memory near exhaustion (on purpose due to the above) leads to pathology. If the system is forced to swap to fill a memory request for ZFS it is possible for the zio_ thread in question to block on that request until the pagedaemon can clear enough room for for allocation to be granted. I have instrumented the ZFS allocation code sufficiently with dtrace to show that with heavy read/write I/O loads, especially on a degraded pool that is resilvering (thus cutting the maximum I/O performance materially) even though the ARC code *should* force eviction of sufficient cache to prevent materially invading the paging threshold with UMA on the fact that it does not reap until the ARC maintenance thread gets to it means I can produce *mid-triple-digit* free RAM page counts (that is, about two *megabytes*!) immediately following allocation requests -- and wicked, nasty stall conditions, some lasting for several minutes where anything requiring image activation (or recall from the swap) is non-responsive as all (or virtually all) of the zio_ threads are blocked waiting for the pagedaemon. This is on a 12GB machine with a normal paging threshold of 21,000 pages. The interesting thing about the pathology is that it presents as what appears to be a "resonance" sort of behavior; that is, it creates an oscillating condition in free memory that gets worse against a constant load profile until the system starts refusing service (the "stalls") and, if I continue to press my I/O demand into that condition I have managed to produce a couple of panics from outright RAM exhaustion. The original patch I wrote dramatically reduced the risk because it pulled the ZFS ARC cache out of the paging threshold and to the vm_free_target point. It did not completely eliminate it due to the UMA interaction problem, which took a *lot* of effort to instrument sufficiently to prove. Pulling ARC out of the paging threshold *and* limiting dirty buffer memory to the difference between current free RAM and the paging threshold on a dynamic basis completely eliminates the problem (because it prevents that invasion of the threshold from happening in real time, and thus the reap calls from the arc maintenance thread is sufficient) but that apparently is not considered an "acceptable" fix. Turning off UMA works as well by removing the oscillation dynamic entirely but has a performance hit associated with it. My current effort is to build a heuristic inside in the ARC ram allocator that will detect the incipient onset of this condition. I am currently able to get to the point where the code "dampens" the oscillation sufficiently to prevent outright RAM exhaustion, but not quickly enough to remain out of danger of a stall. That's not good enough because once the degenerative behavior starts it gets progressively worse for a constant workload. There's no guarantee I'll get where I want to go with this effort but I'm giving it my best shot as I'm aware that UMA is considered a "good thing" in terms of performance. I'll post further code if/when I get something that survives my torture test with UMA on and doesn't throw dtrace probe data that makes me uncomfortable. At present I believe I can get there. 787975 143 karl 2014-09-22 04:39:47 +0000 I believe I have a smoking gun on the UMA memory allocator misbehavior. zio_buf_65536: 65536, 0, 656, 40554, 25254813, 0, 0, 41MB, 2.475GB, 2.515GB That's a particularly pathological case that is easily reproduced. All that is required is, on a degraded pool (to slow it's maximum I/O rate down) to do a read of all files on it to /dev/null (e.g. "find . -type f -exec cat {} >/dev/null \;") and then at the same time perform a copy of files within the pool (e.g. "pax -r -w -v somedirectory/* anotherdirectory/") Since the copy is local it is all done with a fixed-sized block (e.g. there's no TCP congestion control that impacts write block size to splay the block requests all over the hash table.) Specifically, all the I/Os are in the 64k block size in the UMA allocator. Here's the problem -- at the moment I took that snapshot there were 656 of those buffers currently in use, but over 40,000, or 2.475 *gigabytes*, of RAM "free" in that segment of the pool. In other words *rather than reassign one of the existing 40,000+ "free" UMA buffers the system went and grabbed another one, and it did it over 40,000 times!* This pathology of handing back new memory instead of re-using the "free" buffers in that pool that the system already has continues until the ZFS low memory warnings trip, then the reap routine is called and magically that 3GB+ of RAM reappears all at once. In the meantime the ARC cache has been evicted on bogus memory pressure. This is broken, badly -- those free buffers should be reassigned without taking a new allocation. The impact of the pathology is extraordinary under heavy load as it produces extremely large oscillations in the system RAM state which both ZFS and the VM system have no effective means to deal with. I have code that I've stuck in the ZFS allocator that prevents it from blowing up at this point by detecting the low memory condition when it crosses the vm_free_target barrier and calling the reap routine to clear out the free allocations that are not being reused as they should be. While that does result in a system that doesn't blow up or stall it doesn't solve the actual problem but rather works around it, as did the original patch I posted (and the one that dynamically varied write buffers to compensate for the extreme hysteresis in the memory state.) The correct fix will require finding out why UMA is not returning a free buffer that it has in the cache instead of allocating a new one, but until the UMA code is repaired the approach in comment 140, which includes disabling UMA, appears to be the only sane option. 788034 144 avg 2014-09-22 13:51:26 +0000 (In reply to karl from comment #143) Just an assorted list of things to consider, perhaps it will lead to some ideas to try. - were the new allocations all 64KB sized? if not then they could not make use of zio_buf_65536 cached objects. - cached items from UMA zones are really freed only when the paging threshold is reached and the pagedaemon makes a pageout pass. - the pagedaemon first posts vm_lowmem and then calls uma_reclaim(). - the event handlers are invoked synchronously (and directly). - additionally, arc_lowmem() handler will block until the arc reclaim thread makes a pass. - the above means that there is no normal paging out nor uma reclaiming until the arc reclaim thread evicts some of the cache. - which means that any memory that the arc reclaim thread needs while doing its job or memory that is needed by other threads (including zfs ones) digs deeper into the page reserve - zfs memory throttling may occur because of that (see arc_memory_throttle()) - additionally, there is vm.lowmem_period knob. vm_lowmem and uma_reclaim() can not be called more often than that period allows Personally, what I'd try first is make arc_lowmem() non-blocking. IMO, it should just wake up the arc reclaim thread and return. 788035 145 avg 2014-09-22 13:52:36 +0000 Changing the status because what's been committed does not seem to be a final solution at all. 788064 146 karl 2014-09-22 17:01:00 +0000 OK, I've traced it further using AVG's touchpoints and now fully understand exactly what is going on. Nobody is going to like this, but my previous mitigation strategy is entirely effective at preventing the stalls. I will explain. ZFS allocates dirty buffers for write data subject to two parameters; dirty_max and dirty_max_max. The former is 10% of RAM by default, the latter is 4GB. The lesser of the two is the nominal limit. Read buffers are less of a problem because a read comes FROM the disk and there is no "backlog"; that is, the system memory is faster than the I/O and thus there is no artificial pressure. Writes are the opposite; there is always pressure any time the write rate exceeds the physical I/O rate of the system. Dirty_max limits the total "in flight" data that can be in process. UMA makes this situation untenable in the general sense, because for most workloads write block size is highly variable. But UMA silos data into buffer blocks of various sizes, and can only re-use a block of a given size. That is, if I want a 64k block of RAM but there are two 32K ones and no 64K ones, I must allocate a new 64K block. Now contemplate what happens in an environment where the system does not keep up with the native I/O rate for any material amount of time. For each moment during which the system is behind it will allocate up to 10% of the total system memory to dirty buffers, and take them from UMA for each particular size that is being written. Those buffers, after the write completes, are returned to the UMA pool but are not freed back to the system. Only a call to kmem_reap() (or it's sub-calls that only act on some of the kegs) actually returns space. So let us take the existing 12GB system that I am testing on with a SMB client that is doing a lot of write I/O. Due to TCP windowing size control the network stack tries to optimize the bandwidth delay product so as to produce a smooth flow of information. This means that the block size presented to the system for writes is highly variable. That in turn splays UMA allocation requests all over the map as the I/O delays and thus the results of that computation (and thus the block size) is also variable. The consequence of this is not a maximum of 1.2Gb of "unused" buffers in the UMA system at any given point in time (that is, dirty_max when fully drained) it is a potential *unlimited* multiplication of that 1.2Gb! In actual practice it is easy to manage to accumulate 3, 4, or even 5Gb of "Free" UMA data in the system this way, evicting the ARC cache the entire time, because the block sizes requested in a given burst are not available in that size and thus must be allocated, even though a gigabyte or more is available in another size. There is no fix for this given the architecture of how the UMA memory system works and the way ZFS uses it. What I can do is mitigate the damage through a couple of strategies, both of which I know work from testing but both of which were discarded when presented. I argue they should be reconsidered as a group and active if UMA is turned on, specifically: 1. Set the ARC eviction threshold to approximately vm_free_target (NOT above it, as that provokes bad behavior in that it preferences inact and cache pages over ARC.) 2. Dynamically tune the dirty_write_max to the difference between current actual free memory and the paging threshold. When RAM is plentiful this allows the full 10% of RAM to be used for dirty buffers. When it is not it halts the rapid expansion of free-and-non-reallocable UMA storage (because the block size requested is not an exact match) and materially reduces the pressure coming from the above. 3. When an ARC allocation is made and we detect we are under vm_free_target, call kmem_reap(). This should not happen *if* the arc maintenance thread gets there first (since it also evicts and makes calls to the reaping routines) but due to the fact that thread is asynchronous and the allocation is on-demand, it still is likely to be able to happen occasionally. All three can be conditioned on the use of UMA; those who do not wish to use UMA need none of those protections. If UMA is on, however, without them you're going to see extreme oscillations in free memory for any workload that has highly-variable write block sizes going to the ZFS volumes that exceed the system's I/O bandwidth. What we have, basically, is a design limitation that was not taken into consideration and steps to mitigate the harm it does need to be applied. I will work up, test and validate the previous effort plus #3 and put it through my torture test, posting the results. 788103 147 gibbs 2014-09-22 20:07:18 +0000 The buffer sizes allocated via zio_buf_alloc() are generally related to file system record size, not the access size of the client. When compression is on, or the file system is so fragmented as to trigger gang block allocation, additional, temporary buffers are required which will be smaller than the record size (typically 128k for data blocks, 16k for metadata). Similar temporary buffer allocation will occur for the parity blocks for the RAIDZ transform and for I/O aggregation in vdev_queue.c. Are you writing a lot of sub-128k files, or using compression? In your RAIDZ, what is the typical I/O size going to individual disks? I'm trying to better understand the spike in usage for the 64k bucket on your system and whether it is due to write inflation (these additional temporary buffers) or is really due to data held in the ARC. Since the temporary allocations are released to UMA as soon as the I/O completes, the VM system should be able to reclaim the majority of them on demand. However, if we really do want to avoid the cost of the VM seeing a page shortage, we'll need to estimate the memory overhead for retiring dirty data (which could be 2x the size of the actual data and metadata) and reclaim within ZFS to vm_free_target + that amount before starting the I/O pipeline. Alternatively, we could notice the encroachment on the limit in zio_buf_alloc(), and trigger reclamation there. For these temporary buffers, waiting for the ARC to do the reclamation may be too late. All the above assumes that temporary zio buffer allocation is part of the problem - a hypothesis I'll try to validate on my systems here. 788105 148 karl 2014-09-22 20:25:53 +0000 Compression is off on this filesystem on the test machine (it typically is on and set to lz4 for filesystems on the production machines, however); the pool in question is a raidz2. The blocksize is 128k (default) on that filesystem as well. With this load (internal pax copy + a cat of all the files to /dev/null) the system is stable although the oscillation in free memory is pretty extreme in the face of static load (the size of dirty_data_max.) The instability comes when you start getting a mix of block sizes in there and effectively amplify that free-and-not-reallocated memory from the dirty buffers times the number of disparate buffer sizes that get used. With reads only (just the "cat") the problem doesn't manifest; the system gets to a steady state on RAM and regular arc replacement works just fine and there is no large group of UMA buffers that are free and unused compared against the allocated ones in the various buckets. 788218 149 147607 karl 2014-09-23 17:49:01 +0000 Created attachment 147607 Current working patch against 10-Stable-BETA2 This is my current working proposal; it has the following characteristics on top of Steve's original refactor: 1. Moves the ZFS UMA reap routines to their own function so they can be used from other than just in the ARC maintenance thread. 2. If UMA is enabled calls a UMA reclaim every 10 passes through the ARC maintenance thread. Under normal (non-pressured) RAM conditions this occurs once every 10 seconds and keeps the UMA area clean of burst I/O buffer demand that is not being reused. 3. If UMA is enabled, we are under RAM pressure at the time of allocation, AND we evicted ARC to make room and yet there is still RAM pressure despite the eviction, presume UMA bloat is the cause and call the UMA reaping routines. (This has a dtrace associated with it; code for that follows if you wish to track it.) This test should never pass with a negative paging margin; that it does is hard evidence that the system allegedly returned memory that has a low probability of being able to be reused (because it's in the wrong UMA bucket.) 4. Sets the arc free target to halfway between the paging threshold and vm_free_target; this is a tunable if you wish to set it elsewhere (specifically, some argue it should be at the paging threshold. I strongly disagree but feel free to experiment with that [vfs.zfs.arc_free_target] and determine which provides superior results under your workload -- it is dynamically tunable while the system is in operation.) This should NOT be set above vm_free_target except in extraordinary (and very unlikely) circumstances as doing so preferences inactive and cache pages over ARC. 5. If UMA is turned on implements a dynamic dirty write buffer resize when under memory pressure. Normally dirty write buffers are limited to a fixed 10% of system memory with a maximum of 4GB. The dynamic resizing code adds a further test, restricting dirty write buffers to the difference between the paging threshold and current system free RAM, with a minimum of 256MB, should that be less than the previous tests would allow. This results, in my testing, in a material improvement in I/O convergence against available I/O bandwidth when the system is under stress. The above heuristic appears to provide an excellent balance between the interacting dynamics involved with UMA turned on, limiting the burst memory pressure from write I/Os to a reasonable value that, in turn, allows the UMA cleanup code to keep up when the system is under stress. It also prevents huge amounts of free RAM that accumulated during an I/O stress event from sitting indefinitely in the UMA free list in preference to ARC cache space, and in my testing is 100% effective at preventing "stalls" and other related bad behavior, especially for interactive sessions, while having no perceptible impact on I/O performance. Comments from others who try the code are appreciated. 788221 150 147609 karl 2014-09-23 17:51:27 +0000 Created attachment 147609 dtrace script for the above This dtrace script contains two calls; the first fires if there is a UMA reap called from inside the allocator (indicting memory pressure that resulted in eviction and needs cleaning at the kernel level) and the second, commented out, prints for each pass through dmu_tx on a write buffer and shows the dynamic sizing. The latter is commented out as it produces a great deal of output under heavy I/O load and thus is only useful for spot checks if you suspect misbehavior. 788588 151 avg 2014-09-26 16:07:01 +0000 I suggest that people who are affected by the clearly inefficient behavior of uma(9) disable usage of uma for zio allocation. Meanwhile we should work on improving uma behavior as a separate issue. In other words, I do not see a need for kludges in arc code only to compensate for uma's problem. I think that we need to periodically trim cached buckets of uma zones. But we should not throw away all of them as this would negatively impact performance and almost defeat uma benefits. So there should be some stats collection to estimate working set size for each zone, so that we do not reduce the cache too much unless really necessary. I am tempted to suggest that pagedaemon could be doing those jobs. 788596 152 karl 2014-09-26 16:47:46 +0000 (In reply to Andriy Gapon from comment #151) > I suggest that people who are affected by the clearly inefficient behavior > of uma(9) disable usage of uma for zio allocation. > Meanwhile we should work on improving uma behavior as a separate issue. > > In other words, I do not see a need for kludges in arc code only to > compensate for uma's problem. Except that's it not really UMA's problem, per-se. UMA is working as designed. It is ZFS' abuse of UMA's design. Specifically, UMA is designed for quick allocation where there may be constructed items that are expensive to put together (e.g. things that require a mutex or similar to set up) and which can be re-used. Those may also have an associated data block of arbitrary but known (and therefore fixed) size. In that regard it works extremely well. ZFS works fine in the general ARC (read) cache sense within this paradigm. It violates the intent on a gross basis when deferred write (that is, dirty data) buffering is involved, because a data data buffer could be of any size. In addition it is entirely possible (and indeed at least somewhat likely) to have large bursts of dirty (asynchronous) write data outstanding in a given size in one instant, and then have that data outstanding in a different size in another. ZFS imposes a dirty data maximum on a per-pool basis but it is sized predicated on system RAM. This is inherently wrong-headed because the maximum productive use of such a cache is determined not by system memory but rather by I/O channel performance, which varies from system to system and also in many cases from pool to pool or even vdev to vdev (e.g. the system that contains a high-performance SSD pool, and a second of much lower-performance spinning rust.) The I/O scheduler (by default) will not apply artificial delay until 60% of that cache is in use (which is ridiculously large for spinning rust in many cases, especially with older, slower drives in a raidz configuration) and will not hard-limit until it fills. UMA multiplies the maximum potential dirty data RAM allocation by the number of different size blocks queued for writing, which makes the original bad decision much worse and renders the code's ability to determine whether memory really is low or whether a requested allocation will be returned from an existing but idle RAM allocation impossible. > I think that we need to periodically trim cached buckets of uma zones. Yes, but I believe that misses the essence of the issue -- ZFS is abusing the original intent of how UMA is architected. This is an annoyance (it limits ARC write cache size) during times of little RAM pressure and highly-invariant (size-wise) write buffer use. It becomes a big problem and leads to pathology when the system is under memory stress and write buffer size is highly-variable and beyond the ability of the system's I/O channels to drain. Network I/O and degraded pools both add to the probability of trouble because the first tends to splay out write buffer size and the second materially harms end-to-end I/O channel performance. > But > we should not throw away all of them as this would negatively impact > performance and almost defeat uma benefits. So there should be some stats > collection to estimate working set size for each zone, so that we do not > reduce the cache too much unless really necessary. I am tempted to suggest > that pagedaemon could be doing those jobs. I argue that's just a kludge to cover a design problem as well, and embedding it into the system (rather than restricting it to the ZFS code) is the wrong direction to take. It appears to me that the correct option overall is to not abuse UMA in the first place. Specifically, dirty write buffer allocation is one that needs examination on a more-systemic basis, arguably moving it to a facility that is not part of UMA but rather allocates wired RAM and manages it internally to ZFS itself. At the same time the dirty data buffer sizing should be computed predicated on measured I/O subsystem performance on a per-pool basis rather than taking a blanket allocation based on RAM size. By removing dirty write buffers from UMA the problem with UMA is resolved. By having ZFS do its own allocation and management for dirty write buffers it can have one pool of space that it can size dynamically predicated on available system memory or optimum throughput (whichever is less), with a maximum as is now the case but across the entire system rather than per-pool along with a per-pool limit that is computed predicated on I/O subsystem performance for each pool. But that is a pretty significant change to the code and one that certainly ought to be coordinated with Illumos, since the impact on UMA is not limited to FreeBSD; indeed, it applies across-the-board. The rest of how ZFS uses UMA is both ok and of positive impact on performance. It is specifically the abuse of UMA to hold dirty write buffers that leads to the problem. I agree that for many people the right choice is to run Steve's refactor with UMA turned off. But there are many people who argue that the UMA performance improvement is worthwhile (I happen to be one of them.) So for those who want to use UMA pending examination and refactoring of the way ZFS does write buffering the patch under consideration stabilizes the system when UMA is on and yet provides most (but not all) of the potential CPU saving that UMA brings to the table. I have another turn of this code under test that allows tuning of the dirty data maximum and honoring it (when the admin wishes to) along with a sysctl to disable the dynamic sizing entirely if you find it limits write I/O performance inappropriately. I have not been able to get the patched code to misbehave in that fashion nor has anyone reported it, but it certainly appears possible, particularly in the case of very-high-performance I/O subsystems, and as such the ability to turn that aspect of it off is something I have taken some time to add and am now testing. 788622 153 rynunes 2014-09-26 20:22:44 +0000 After speaking to Karl (thanks again for your time by the way), I ended up upgrading freebsd10-release to 10-stable, disabled UMA and applied Steve's refactor patch. I am in the process of trying to get the replicated partner to exhibit the same zpool deadlocks as the primary so unfortunately I won't know if this patch will have truly worked for a few days. The reason I am so curious is out of our 6 pairs this one server deadlocked almost every night, while two others only have locked up once. They are all currently in the process of migrating a large amount of data to them over multiple rsync processes while send/receiving to spares over 10Gb. One other interesting observation I have made is post stable/patch my iozone 'WRITE' results have doubled in speed. I verified UMA was in fact disabled so that shouldn't be skewing any of my results. I tested and retested thinking it was just a one off result, but my results were all fairly consistent. Thank you to everyone contributing to the resolution of this. 788738 154 rynunes 2014-09-27 19:44:24 +0000 This patch has seemingly made things worse. Had one of my other systems zpool deadlock so I updated to 10-stable, disabled UMA, applied Steve's patch. The system was only up for an 1:23 before the zpool deadlocked. Oddly enough this didn't happen when I would have expected it to.. Still plenty of free memory and the system hadn't even started paging. Cant kill the rsync's zpool status, zfs, etc just lock the shell up. Only option is a hard reboot... last pid: 1864; load averages: 0.07, 0.04, 0.05 up 0+01:22:41 15:39:37 87 processes: 1 running, 86 sleeping CPU: 0.0% user, 0.0% nice, 0.0% system, 0.0% interrupt, 100% idle Mem: 194M Active, 170M Inact, 34G Wired, 91G Free ARC: 27G Total, 5750M MFU, 3091M MRU, 3991M Anon, 161M Header, 14G Other Swap: 32G Total, 32G Free PID USERNAME THR PRI NICE SIZE RES STATE C TIME WCPU COMMAND 1445 root 1 20 0 25068K 11796K dp->dp 7 0:21 0.00% rsync 1444 root 1 20 0 16876K 5716K dp->dp 6 0:08 0.00% rsync 1446 root 1 20 0 25068K 14004K dp->dp 5 0:05 0.00% rsync 788744 155 smh 2014-09-27 20:05:27 +0000 Given the free memory and process states, I'd say that's highly likely to be unrelated to the patch as you'll simply not be triggering any of the altered code paths. 788746 156 smh 2014-09-27 20:06:39 +0000 To debug that hang procstat -kk and obtain a kernel dump if you can. 788747 157 147733 smh 2014-09-27 20:10:27 +0000 Created attachment 147733 ARC reclaim refactor + uma clear down (against stable/10) This version is very much WIP it builds on ARC reclaim refactor (against stable/10) adding automatic UMA free space clear down. The following new sysctls are available: * vfs.zfs.arc_cache_reclaim_period * vfs.zfs.arc_cache_reclaim_partial * vfs.zfs.arc_cache_free_max * vfs.zfs.arc_cache_free_period * vfs.zfs.arc_cache_target The ARC reclaim thread now monitors triggers a free size based cleanup of its UMA zones. This cleanup has multiple strategies: 1. ARC_CACHE_RECLAIM_SIZE Every arc_cache_free_period we that all zones have no more than arc_cache_free_max of free space. This prevents zones which spike from sitting with large amounts of ram allocated but unused (free). 2. ARC_CACHE_RECLAIM_NOW If free memory is lower than arc_cache_target a full cleanup of all zones is triggered. If zfs_arc_cache_partial is none zero then this strategy will return early (not process all zones) if free memory is more than arc_cache_target. 3. ARC_CACHE_RECLAIM_FORCE The same as ARC_CACHE_RECLAIM_NOW but will ignore when the last reclaim ran. ARC cache reclaim for ARC_CACHE_RECLAIM_NOW and ARC_CACHE_RECLAIM_SIZE strategies will only run at most once every arc_cache_reclaim_period. Before allocating new buffers arc_get_data_buf checks if allocating this amount of memory would cross cache reclaim threshold and if so it runs a cache reclaim with ARC_CACHE_RECLAIM_NOW. 788771 158 147738 smh 2014-09-27 23:50:14 +0000 Created attachment 147738 ARC reclaim refactor + uma clear down (against stable/10) Fixes for ARC_CACHE_RECLAIM_FORCE strategy. 788776 159 rynunes 2014-09-28 00:18:17 +0000 This was definitely a red-herring as the behavior just didn't match up to what I was seeing before (with the exception of the deadlock). I will keep an eye on it. (In reply to noons from comment #154) > This patch has seemingly made things worse. Had one of my other systems > zpool deadlock so I updated to 10-stable, disabled UMA, applied Steve's > patch. The system was only up for an 1:23 before the zpool deadlocked. Oddly > enough this didn't happen when I would have expected it to.. Still plenty of > free memory and the system hadn't even started paging. Cant kill the rsync's > zpool status, zfs, etc just lock the shell up. Only option is a hard > reboot... > > > last pid: 1864; load averages: 0.07, 0.04, 0.05 up 0+01:22:41 > 15:39:37 > 87 processes: 1 running, 86 sleeping > CPU: 0.0% user, 0.0% nice, 0.0% system, 0.0% interrupt, 100% idle > Mem: 194M Active, 170M Inact, 34G Wired, 91G Free > ARC: 27G Total, 5750M MFU, 3091M MRU, 3991M Anon, 161M Header, 14G Other > Swap: 32G Total, 32G Free > > PID USERNAME THR PRI NICE SIZE RES STATE C TIME WCPU COMMAND > 1445 root 1 20 0 25068K 11796K dp->dp 7 0:21 0.00% rsync > 1444 root 1 20 0 16876K 5716K dp->dp 6 0:08 0.00% rsync > 1446 root 1 20 0 25068K 14004K dp->dp 5 0:05 0.00% rsync 788834 160 rynunes 2014-09-28 15:18:02 +0000 This can't be right. Running rsync's the Arc was at 90G free memory was around 8-10G stepped away for 20 min to get coffee and came back to this.. Mem: 58M Active, 396M Inact, 123G Wired, 1012K Cache, 1310M Free ARC: 15G Total, 850M MFU, 6930M MRU, 19M Anon, 3619M Header, 4823M Other Swap: 32G Total, 32G Free Where did all my memory go along with my ARC? 788835 161 smh 2014-09-28 15:26:05 +0000 (In reply to noons from comment #160) > This can't be right. Running rsync's the Arc was at 90G free memory was > around 8-10G stepped away for 20 min to get coffee and came back to this.. > > Mem: 58M Active, 396M Inact, 123G Wired, 1012K Cache, 1310M Free > ARC: 15G Total, 850M MFU, 6930M MRU, 19M Anon, 3619M Header, 4823M Other > Swap: 32G Total, 32G Free > > Where did all my memory go along with my ARC? No that doesn't look right, I suspect your seeing it all in uma free. What does vmstat -z show? Which patch are you running? 788836 162 rynunes 2014-09-28 15:31:41 +0000 (In reply to Steven Hartland from comment #161) > (In reply to noons from comment #160) > > This can't be right. Running rsync's the Arc was at 90G free memory was > > around 8-10G stepped away for 20 min to get coffee and came back to this.. > > > > Mem: 58M Active, 396M Inact, 123G Wired, 1012K Cache, 1310M Free > > ARC: 15G Total, 850M MFU, 6930M MRU, 19M Anon, 3619M Header, 4823M Other > > Swap: 32G Total, 32G Free > > > > Where did all my memory go along with my ARC? > > No that doesn't look right, I suspect your seeing it all in uma free. > > What does vmstat -z show? > Which patch are you running? 10-stable, Arc Reclaim Refactor Fix and UMA disabled. http://pastebin.com/PB1ZyVP6 Oddly enough something 'burst' my free memory just went back to 'normal' and my ARC is begging to grow again.. Mem: 71M Active, 400M Inact, 43G Wired, 976K Cache, 81G Free ARC: 26G Total, 1890M MFU, 17G MRU, 54M Anon, 3703M Header, 3787M Other Swap: 32G Total, 32G Free 788838 163 smh 2014-09-28 15:42:04 +0000 (In reply to noons from comment #162) > 10-stable, Arc Reclaim Refactor Fix and UMA disabled. > > http://pastebin.com/PB1ZyVP6 > > > Oddly enough something 'burst' my free memory just went back to 'normal' and > my ARC is begging to grow again.. > > Mem: 71M Active, 400M Inact, 43G Wired, 976K Cache, 81G Free > ARC: 26G Total, 1890M MFU, 17G MRU, 54M Anon, 3703M Header, 3787M Other > Swap: 32G Total, 32G Free If its already cleared up hard to tell but even with those stats you have significant amounts of memory tied up in uma free. 6.64GB of which was due to ZFS and 11.29GB from other sources. oused: 16.962GB, ofree: 11.291GB, ototal: 28.254GB zused: 6.224GB, zfree: 6.649GB, ztotal: 12.872GB used: 23.186GB, free: 17.940GB, total: 41.126GB 788839 164 147754 smh 2014-09-28 15:44:48 +0000 Created attachment 147754 UMA summary script This script does some summary of UMA usage, where zused = ZFS usage, oused = oher usage. 788845 165 rynunes 2014-09-28 16:19:34 +0000 (In reply to Steven Hartland from comment #163) > (In reply to noons from comment #162) > > 10-stable, Arc Reclaim Refactor Fix and UMA disabled. > > > > http://pastebin.com/PB1ZyVP6 > > > > > > Oddly enough something 'burst' my free memory just went back to 'normal' and > > my ARC is begging to grow again.. > > > > Mem: 71M Active, 400M Inact, 43G Wired, 976K Cache, 81G Free > > ARC: 26G Total, 1890M MFU, 17G MRU, 54M Anon, 3703M Header, 3787M Other > > Swap: 32G Total, 32G Free > > If its already cleared up hard to tell but even with those stats you have > significant amounts of memory tied up in uma free. 6.64GB of which was due > to ZFS and 11.29GB from other sources. > > oused: 16.962GB, ofree: 11.291GB, ototal: 28.254GB > zused: 6.224GB, zfree: 6.649GB, ztotal: 12.872GB > used: 23.186GB, free: 17.940GB, total: 41.126GB Ok this was fairly easy to reproduce, I ended up starting new rsync jobs to an empty folder an the behavior happened almost immediately. I watched the ark drop to the min along with my free memory.. http://pastebin.com/yw6T30GK I also attempted to run your UMA script, but doesn't appear to be returning anything. 788851 166 smh 2014-09-28 17:01:27 +0000 (In reply to noons from comment #165) > > I also attempted to run your UMA script, but doesn't appear to be returning > anything. It takes the input from vmstat -z so you run: vmstat -z | vmstat.awk 788856 167 rynunes 2014-09-28 17:34:50 +0000 (In reply to Steven Hartland from comment #166) > (In reply to noons from comment #165) > > > > I also attempted to run your UMA script, but doesn't appear to be returning > > anything. > > It takes the input from vmstat -z so you run: > vmstat -z | vmstat.awk Ahh thanks! See my results below... I've been testing this behavior and it seems that the ARC begins evicting as soon as it grows above 100GB, then it rapidly evicts until it hits the minimum. Another interesting observation is as soon as I initiate a large amount of reads (rsync to another box for example) the free memory bursts instantly to around 90G, if I don't initiate any reads then the ARC remains at 15GB and free memory hovers around 1G. I am kind of wondering if I should just set my arc_max to 100G as my other 10-release unpatched boxes never go higher then 105G anyway. It still doesn't explain the behavior... http://pastebin.com/vjSCVCJe 788859 168 smh 2014-09-28 18:15:55 +0000 (In reply to noons from comment #167) > Ahh thanks! See my results below... I've been testing this behavior and it > seems that the ARC begins evicting as soon as it grows above 100GB, then it > rapidly evicts until it hits the minimum. Another interesting observation is > as soon as I initiate a large amount of reads (rsync to another box for > example) the free memory bursts instantly to around 90G, if I don't initiate > any reads then the ARC remains at 15GB and free memory hovers around 1G. I > am kind of wondering if I should just set my arc_max to 100G as my other > 10-release unpatched boxes never go higher then 105G anyway. It still > doesn't explain the behavior... > > http://pastebin.com/vjSCVCJe Wow you have 84GB in the free 65536 zone. I have a quick look but cant see what that zone is used by, I'm guessing it could be malloc provider or something else generic. The general pattern I'm getting the impression that the UMA doesn't deal very well with spiky loads. How long does it take to recover from this? If you use turn on ZFS UMA support what do you see? After that does how does ARC reclaim refactor + uma clear down (against stable/10) patch instead of the baseline patch affect that behaviour? 788860 169 smh 2014-09-28 18:24:50 +0000 noons do you have any custom ZFS sysclt's active at all? 788885 170 rynunes 2014-09-28 21:17:20 +0000 (In reply to Steven Hartland from comment #169) > noons do you have any custom ZFS sysclt's active at all? Only what was listed below was added to my loader.conf, no values manually set either. The memory usage/ARC stays like this until I call some sort of large read (right now I am migrating files to the server so for the most part it is doing just writes). As soon as I call an rsync copying files from this box vs to, free memory jumps almost instantly to normal levels and my ARC begins to rise again. vfs.root.mountfrom="zfs:system" vfs.zfs.zio.use_uma="0" Interestingly enough with 10-release once memory began to get into the danger zone ~1.5G (for whatever reason) that is when the system would start to page yet the arc would remain fairly stable (maybe drop 10G then rise back up again). All that is going on is an rsync to the local box and 10 min zfs sends, so I am not sure where this memory is going. I will try enabling UMA and will post my results (takes a few hours for the memory to 'leak') 788963 171 karl 2014-09-29 13:14:28 +0000 (In reply to noons from comment #167) > (In reply to Steven Hartland from comment #166) > > (In reply to noons from comment #165) > > > > > > I also attempted to run your UMA script, but doesn't appear to be returning > > > anything. > > > > It takes the input from vmstat -z so you run: > > vmstat -z | vmstat.awk > > Ahh thanks! See my results below... I've been testing this behavior and it > seems that the ARC begins evicting as soon as it grows above 100GB, then it > rapidly evicts until it hits the minimum. Another interesting observation is > as soon as I initiate a large amount of reads (rsync to another box for > example) the free memory bursts instantly to around 90G, if I don't initiate > any reads then the ARC remains at 15GB and free memory hovers around 1G. I > am kind of wondering if I should just set my arc_max to 100G as my other > 10-release unpatched boxes never go higher then 105G anyway. It still > doesn't explain the behavior... > > http://pastebin.com/vjSCVCJe As Steve noted you have an utterly enormous amount of RAM out in UMA that is not being used. This looks like yet another manifestation of UMA out-of-control. UMA *cannot* handle "spiky" loads -- by definition it does not (ever) return released memory on its own; something has to come along and tell it clean up after itself. If you have a situation where you request 10Gig of RAM in a given UMA size and then release it, that 10 Gig remains allocated but available for another request later. The problem comes in when that spiky load doesn't come back any time soon, which leaves that RAM allocated indefinitely, or worse it comes back *in a different size request*, which results in multiplying the amount of RAM consumed. The latter is really, really bad. That 83Gb number looks awful but there's plenty of other bad news in that printout; you have over 10Gb out and unused between three other buckets, and only one of them looks reasonably-coherent against current requirements (the 16k block.) You need to find out where that's coming from..... it does not appear to be ZFS related. 788969 172 rynunes 2014-09-29 13:51:23 +0000 (In reply to karl from comment #171) > (In reply to noons from comment #167) > > (In reply to Steven Hartland from comment #166) > > > (In reply to noons from comment #165) > > > > > > > > I also attempted to run your UMA script, but doesn't appear to be returning > > > > anything. > > > > > > It takes the input from vmstat -z so you run: > > > vmstat -z | vmstat.awk > > > > Ahh thanks! See my results below... I've been testing this behavior and it > > seems that the ARC begins evicting as soon as it grows above 100GB, then it > > rapidly evicts until it hits the minimum. Another interesting observation is > > as soon as I initiate a large amount of reads (rsync to another box for > > example) the free memory bursts instantly to around 90G, if I don't initiate > > any reads then the ARC remains at 15GB and free memory hovers around 1G. I > > am kind of wondering if I should just set my arc_max to 100G as my other > > 10-release unpatched boxes never go higher then 105G anyway. It still > > doesn't explain the behavior... > > > > http://pastebin.com/vjSCVCJe > > As Steve noted you have an utterly enormous amount of RAM out in UMA that is > not being used. This looks like yet another manifestation of UMA > out-of-control. > > UMA *cannot* handle "spiky" loads -- by definition it does not (ever) return > released memory on its own; something has to come along and tell it clean up > after itself. If you have a situation where you request 10Gig of RAM in a > given UMA size and then release it, that 10 Gig remains allocated but > available for another request later. > > The problem comes in when that spiky load doesn't come back any time soon, > which leaves that RAM allocated indefinitely, or worse it comes back *in a > different size request*, which results in multiplying the amount of RAM > consumed. The latter is really, really bad. > > That 83Gb number looks awful but there's plenty of other bad news in that > printout; you have over 10Gb out and unused between three other buckets, and > only one of them looks reasonably-coherent against current requirements (the > 16k block.) > > You need to find out where that's coming from..... it does not appear to be > ZFS related. I am not sure what else it could be then. Only thing running are 3 rsync jobs and send/recv (using zrep for snapshot management). Maybe the amount of files I am rsync'ing is causing the pain, maybe send/resv? 788971 173 karl 2014-09-29 14:10:00 +0000 (In reply to noons from comment #172) > I am not sure what else it could be then. Only thing running are 3 rsync > jobs and send/recv (using zrep for snapshot management). Maybe the amount of > files I am rsync'ing is causing the pain, maybe send/resv? Send/recv should not be doing this; this ought to be coming from something that the kernel is up to, not user-space applications. These moves are going over the network (not on the same machine) yes? How saturated are your I/O channels during this -- are they being slammed (e.g. 'gstat' showing your spindles at 100% load and material backlogs in the I/O queues?) That's the paradigm that provokes trouble on my machine with UMA on and ZFS, and that my latest tries to get around (Steve is going after the same problem with a different approach.) I've not been able to provoke what you're seeing and since you've eliminated ZFS' use of UMA it's coming from somewhere else. I'm quite suspicious of the networking code if you're doing these copies over the network.... 788977 174 rynunes 2014-09-29 14:56:55 +0000 (In reply to karl from comment #173) > (In reply to noons from comment #172) > > > I am not sure what else it could be then. Only thing running are 3 rsync > > jobs and send/recv (using zrep for snapshot management). Maybe the amount of > > files I am rsync'ing is causing the pain, maybe send/resv? > > Send/recv should not be doing this; this ought to be coming from something > that the kernel is up to, not user-space applications. > > These moves are going over the network (not on the same machine) yes? How > saturated are your I/O channels during this -- are they being slammed (e.g. > 'gstat' showing your spindles at 100% load and material backlogs in the I/O > queues?) > > That's the paradigm that provokes trouble on my machine with UMA on and ZFS, > and that my latest tries to get around (Steve is going after the same > problem with a different approach.) I've not been able to provoke what > you're seeing and since you've eliminated ZFS' use of UMA it's coming from > somewhere else. I'm quite suspicious of the networking code if you're doing > these copies over the network.... Woke up to two servers completely deadlocked, one patched one on release. I thought for sure the behavior I was seeing was related to this bug as it seemed to only happen once the memory got saturated and the system was doing heavy paging, but in one instance on a patched server the system deadlocked before the ARC was even populated (1 hour of uptime). This patch definitely solved the paging issues, but causes the ARC to dump down to minimum most likely due to whatever my real issue actually is. Good news is the patch is probably working as expected. I am keeping an eye on gstat and the average is around 20% and spikes to around 50-60 probably when the rsync jobs pick up considerable speed, but I will continue to monitor this. I have witnessed a few times where for around 1-2 min on 10-release some of the disks hit 100% while the others are 0. Trying to confirm if this is happening post stable-patch The rsync itself is being done via a 1G direct connection MTU set to 9000 while send/recv is going over a 10G direct connection. I have 3 rsync jobs running to different subfolders due to the constant pausing of rsync, an issue we have due to many of the folders containing million+ of small files (8k-32k). procstats during deadlock: http://pastebin.com/avixyHDA Anyway if you guys agree this is unrelated to this bug I will have to raise a separate issue as I don't want to pollute this bug thread anymore then I already have. 788988 175 adrian 2014-09-29 16:52:22 +0000 .. can we look at addressing the UMA hoarding as a general thing, separate from ZFS? I think avg is on the right track here - there are two separate problems here. -a 788989 176 smh 2014-09-29 17:36:10 +0000 (In reply to Adrian Chadd from comment #175) > .. can we look at addressing the UMA hoarding as a general thing, separate > from ZFS? > > I think avg is on the right track here - there are two separate problems > here. Yes this is something I've been thinking about and I noticed that UMA already does periodic accounting for hash sizing. I don't believe there's going to be a one size fits all solution so I've toying with the idea of configuring a free threshold on each zone much the same way uma_zone_set_max(..) does for used. That said given how ZFS works and how active it is with its allocations I don't believe that would be sufficient. It needs to be able to actively manage its memory use as in my + uma clear down patch. Now ideally this functionality should be provided by the uma subsystem, but there's still going to need to be interaction there. 788990 177 smh 2014-09-29 17:37:28 +0000 (In reply to noons from comment #174) > procstats during deadlock: > http://pastebin.com/avixyHDA > > Anyway if you guys agree this is unrelated to this bug I will have to raise > a separate issue as I don't want to pollute this bug thread anymore then I > already have. Do you have any zvols in use? If so I may have a patch sitting around here which could fix this deadlock. 789006 178 karl 2014-09-29 19:29:04 +0000 (In reply to Steven Hartland from comment #176) > (In reply to Adrian Chadd from comment #175) > > .. can we look at addressing the UMA hoarding as a general thing, separate > > from ZFS? > > > > I think avg is on the right track here - there are two separate problems > > here. > > Yes this is something I've been thinking about and I noticed that UMA > already does periodic accounting for hash sizing. > > I don't believe there's going to be a one size fits all solution so I've > toying with the idea of configuring a free threshold on each zone much the > same way uma_zone_set_max(..) does for used. > > That said given how ZFS works and how active it is with its allocations I > don't believe that would be sufficient. It needs to be able to actively > manage its memory use as in my + uma clear down patch. > > Now ideally this functionality should be provided by the uma subsystem, but > there's still going to need to be interaction there. If the problem with ZFS and UMA is limited to dirty write allocation (and I believe it is) then the fair question to ask is whether the gains from using UMA for that purpose, with the attendant hackery to keep the space spikes under control (a strategy that may well work; I believe my approach does in the general case but at a material overhead cost; your approach may also work but at a material overhead cost) outweighs the cost of not using UMA for dirty write buffers. That is, does the latency + CPU consumption tip toward using it or not using it? If toward not then there's a decent argument for refactoring the code to not use UMA for dirty write buffers at all. 789012 179 smh 2014-09-29 19:48:54 +0000 (In reply to karl from comment #178) > If the problem with ZFS and UMA is limited to dirty write allocation (and I > believe it is) then the fair question to ask is whether the gains from using > UMA for that purpose, with the attendant hackery to keep the space spikes > under control (a strategy that may well work; I believe my approach does in > the general case but at a material overhead cost; your approach may also > work but at a material overhead cost) outweighs the cost of not using UMA > for dirty write buffers. Actually I don't believe that's the case, there are more issues that stem from UMA not clearing up as readily as it could. > That is, does the latency + CPU consumption tip toward using it or not using > it? If toward not then there's a decent argument for refactoring the code > to not use UMA for dirty write buffers at all. You can achieve that but disabling uma support. If your suggesting dirty buffers should be separate from ARC then that's a totally different matter and could massively balloon the memory requirements as the whole design is around the two sharing memory space. 789014 180 karl 2014-09-29 19:52:20 +0000 (In reply to Steven Hartland from comment #179) > (In reply to karl from comment #178) > > If the problem with ZFS and UMA is limited to dirty write allocation (and I > > believe it is) then the fair question to ask is whether the gains from using > > UMA for that purpose, with the attendant hackery to keep the space spikes > > under control (a strategy that may well work; I believe my approach does in > > the general case but at a material overhead cost; your approach may also > > work but at a material overhead cost) outweighs the cost of not using UMA > > for dirty write buffers. > > Actually I don't believe that's the case, there are more issues that stem > from UMA not clearing up as readily as it could. In the case of other facilities, yes. But in the case of ZFS it appears that the issues can only be triggered during writes. I've yet to be able to reproduce the UMA bloat problems with any sort of read stress test no matter how nasty I get with it. > > That is, does the latency + CPU consumption tip toward using it or not using > > it? If toward not then there's a decent argument for refactoring the code > > to not use UMA for dirty write buffers at all. > > You can achieve that but disabling uma support. > > If your suggesting dirty buffers should be separate from ARC then that's a > totally different matter and could massively balloon the memory requirements > as the whole design is around the two sharing memory space. If that is the case then it would appear to argue for either a very serious refactor of the UMA code or that ZFS is abusing the intent and design of the UMA code and thus it should not use it at all. 789018 181 smh 2014-09-29 20:01:53 +0000 (In reply to karl from comment #180) > In the case of other facilities, yes. But in the case of ZFS it appears > that the issues can only be triggered during writes. I've yet to be able to > reproduce the UMA bloat problems with any sort of read stress test no matter > how nasty I get with it. You may be seeing that in your env but its totally possible for others to be seeing it on reads too. All you need is different apps using different read sizes and you'll get it on read too. > > > That is, does the latency + CPU consumption tip toward using it or not using > > > it? If toward not then there's a decent argument for refactoring the code > > > to not use UMA for dirty write buffers at all. > > > > You can achieve that but disabling uma support. > > > > If your suggesting dirty buffers should be separate from ARC then that's a > > totally different matter and could massively balloon the memory requirements > > as the whole design is around the two sharing memory space. > > If that is the case then it would appear to argue for either a very serious > refactor of the UMA code or that ZFS is abusing the intent and design of the > UMA code and thus it should not use it at all. I'm not sure how serious a refactor is required, but I would agree with Adrian that UMA does appear to need some work to ensure it can deal with spiky workloads that allocate large amounts in zones for short periods, then don't use it again for some time. That said in the general case it shouldn't be too much of an issue if low memory trigger did UMA clear down as one of its first steps. The problem with ZFS is that it looks at how much is used / free when free doesn't include UMA free when potentially it should. 789022 182 karl 2014-09-29 20:31:56 +0000 (In reply to Steven Hartland from comment #181) > (In reply to karl from comment #180) > > In the case of other facilities, yes. But in the case of ZFS it appears > > that the issues can only be triggered during writes. I've yet to be able to > > reproduce the UMA bloat problems with any sort of read stress test no matter > > how nasty I get with it. > > You may be seeing that in your env but its totally possible for others to be > seeing it on reads too. All you need is different apps using different read > sizes and you'll get it on read too. I've tried to generate that condition by opening up large files (many-gigabyte-sized) with random lseeks and read sizes and I can't make the condition manifest itself that way. > > > > That is, does the latency + CPU consumption tip toward using it or not using > > > > it? If toward not then there's a decent argument for refactoring the code > > > > to not use UMA for dirty write buffers at all. > > > > > > You can achieve that but disabling uma support. > > > > > > If your suggesting dirty buffers should be separate from ARC then that's a > > > totally different matter and could massively balloon the memory requirements > > > as the whole design is around the two sharing memory space. > > > > If that is the case then it would appear to argue for either a very serious > > refactor of the UMA code or that ZFS is abusing the intent and design of the > > UMA code and thus it should not use it at all. > > I'm not sure how serious a refactor is required, but I would agree with > Adrian that UMA does appear to need some work to ensure it can deal with > spiky workloads that allocate large amounts in zones for short periods, then > don't use it again for some time. > > That said in the general case it shouldn't be too much of an issue if low > memory trigger did UMA clear down as one of its first steps. Maybe. My testing hasn't led to joy via that route, but I haven't completely given up. Putting that check in the arc maintenance thread (which when not under heavy pressure runs once per second) proved to be insufficiently quick to catch the condition before it got out of hand. Doing so in the allocator (my latest published patch) works but it is arguably wasteful to clear all of the buckets. But is it in practical terms? If there are (relatively) few available slots then the actual work of freeing them should be small. That in turn implies that the overhead of doing that when unnecessary isn't very large, nor is the price paid significant for doing so as a percentage of the whole in terms of the work being done. > > The problem with ZFS is that it looks at how much is used / free when free > doesn't include UMA free when potentially it should. I tried to include that and it led to even worse behavior, but that was because it wasn't fine-grained enough. 789062 183 rynunes 2014-09-30 02:02:37 +0000 (In reply to karl from comment #173) > (In reply to noons from comment #172) > > > I am not sure what else it could be then. Only thing running are 3 rsync > > jobs and send/recv (using zrep for snapshot management). Maybe the amount of > > files I am rsync'ing is causing the pain, maybe send/resv? > > Send/recv should not be doing this; this ought to be coming from something > that the kernel is up to, not user-space applications. > > These moves are going over the network (not on the same machine) yes? How > saturated are your I/O channels during this -- are they being slammed (e.g. > 'gstat' showing your spindles at 100% load and material backlogs in the I/O > queues?) > > That's the paradigm that provokes trouble on my machine with UMA on and ZFS, > and that my latest tries to get around (Steve is going after the same > problem with a different approach.) I've not been able to provoke what > you're seeing and since you've eliminated ZFS' use of UMA it's coming from > somewhere else. I'm quite suspicious of the networking code if you're doing > these copies over the network.... Grasping at straws I thought about what you said Karl and happened to look at netstat. Mbufs denied and jumbo clusters denied were all awfully high and growing, I disabled jumbo frames rebooted and so far I am not seeing the behavior I was yesterday. My ARC is at 100G memory around 4-6G as memory drops arc drops slightly down to 96G and raises back up again. Did I stumble on a bug with the networking stack? I am going to continue monitoring, but it has been healthy like this for hours where yesterday with jumbo frames I repeatedly hit this issue as soon as the arc filled up. There is no other explanation as no other changes were made and even after a reboot yesterday I was hitting the same issue. 789067 184 karl 2014-09-30 02:15:35 +0000 (In reply to noons from comment #183) > (In reply to karl from comment #173) > > (In reply to noons from comment #172) > > > > > I am not sure what else it could be then. Only thing running are 3 rsync > > > jobs and send/recv (using zrep for snapshot management). Maybe the amount of > > > files I am rsync'ing is causing the pain, maybe send/resv? > > > > Send/recv should not be doing this; this ought to be coming from something > > that the kernel is up to, not user-space applications. > > > > These moves are going over the network (not on the same machine) yes? How > > saturated are your I/O channels during this -- are they being slammed (e.g. > > 'gstat' showing your spindles at 100% load and material backlogs in the I/O > > queues?) > > > > That's the paradigm that provokes trouble on my machine with UMA on and ZFS, > > and that my latest tries to get around (Steve is going after the same > > problem with a different approach.) I've not been able to provoke what > > you're seeing and since you've eliminated ZFS' use of UMA it's coming from > > somewhere else. I'm quite suspicious of the networking code if you're doing > > these copies over the network.... > > Grasping at straws I thought about what you said Karl and happened to look > at netstat. Mbufs denied and jumbo clusters denied were all awfully high and > growing, I disabled jumbo frames rebooted and so far I am not seeing the > behavior I was yesterday. My ARC is at 100G memory around 4-6G as memory > drops arc drops slightly down to 96G and raises back up again. > > Did I stumble on a bug with the networking stack? I am going to continue > monitoring, but it has been healthy like this for hours where yesterday with > jumbo frames I repeatedly hit this issue as soon as the arc filled up. There > is no other explanation as no other changes were made and even after a > reboot yesterday I was hitting the same issue. Entirely possible.... see if the problem stays gone; if you're getting mbuf and jumbo clusters denied, yeah, there may well be a problem there, especially with the UMA you had out. It's not proof but it looks like pretty good correlation -- especially if the problem is now gone. 789069 185 smh 2014-09-30 02:20:11 +0000 (In reply to noons from comment #183) > Grasping at straws I thought about what you said Karl and happened to look > at netstat. Mbufs denied and jumbo clusters denied were all awfully high and > growing, I disabled jumbo frames rebooted and so far I am not seeing the > behavior I was yesterday. My ARC is at 100G memory around 4-6G as memory > drops arc drops slightly down to 96G and raises back up again. mbufs are allocated using a UMA zone, so monitor the differences between your vmstat -z in both cases to spot the difference. > Did I stumble on a bug with the networking stack? I am going to continue > monitoring, but it has been healthy like this for hours where yesterday with > jumbo frames I repeatedly hit this issue as soon as the arc filled up. There > is no other explanation as no other changes were made and even after a > reboot yesterday I was hitting the same issue. This could be a side effect of slowing down the incoming data rate due to smaller packet sizes, so also compare your peek throughputs on your interfaces using systat 1 -if. 789073 186 147815 smh 2014-09-30 02:36:57 +0000 Created attachment 147815 ARC reclaim refactor + uma clear down (against stable/10) Fix periodic firing too often, add comments, rename var. 789091 187 147815 avg 2014-09-30 06:35:59 +0000 Comment on attachment 147815 ARC reclaim refactor + uma clear down (against stable/10) This looks horrible. 789108 188 smh 2014-09-30 08:30:15 +0000 (In reply to Andriy Gapon from comment #187) > Comment on attachment 147815 [details] > ARC reclaim refactor + uma clear down (against stable/10) > > This looks horrible. That's why its WIP for testing ideas. 789651 189 commit-hook 2014-10-03 20:35:28 +0000 A commit references this bug: Author: smh Date: Fri Oct 3 20:34:56 UTC 2014 New revision: 272483 URL: https://svnweb.freebsd.org/changeset/base/272483 Log: Refactor ZFS ARC reclaim checks and limits Remove previously added kmem methods in favour of defines which allow diff minimisation between upstream code base. Rebalance ARC free target to be vm_pageout_wakeup_thresh by default which eliminates issue where ARC gets minimised instead of balancing with VM pageout. The restores the target point prior to r270759. Bring in missing upstream only changes which move unused code to further eliminate code differences. Add additional DTRACE probe to aid monitoring of ARC behaviour. Enable upstream i386 code paths on platforms which don't define UMA_MD_SMALL_ALLOC. Fix mixture of byte an page values in arc_memory_throttle i386 code path value assignment of available_memory. PR: 187594 Review: D702 Reviewed by: avg MFC after: 1 week X-MFC-With: r270759 & r270861 Sponsored by: Multiplay Changes: head/sys/cddl/compat/opensolaris/kern/opensolaris_kmem.c head/sys/cddl/compat/opensolaris/sys/kmem.h head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c head/sys/vm/vm_pageout.c 791174 190 will 2014-10-14 13:26:40 +0000 Have you tried turning off ZIL commits on your filesystems (zfs set sync=disabled) to see whether that plays a role in the write performance cliffs you've seen? I know this property change would not be a fix in and of itself, but I do have a local change which may help on top of the ARC interaction changes mentioned. And setting this property on your filesystems is the quickest and easiest way to determine whether that is the case. Can you also comment on what degree your workload involves sync writes? 791175 191 karl 2014-10-14 13:31:28 +0000 (In reply to Will Andrews from comment #190) > Have you tried turning off ZIL commits on your filesystems (zfs set > sync=disabled) to see whether that plays a role in the write performance > cliffs you've seen? > > I know this property change would not be a fix in and of itself, but I do > have a local change which may help on top of the ARC interaction changes > mentioned. And setting this property on your filesystems is the quickest > and easiest way to determine whether that is the case. > > Can you also comment on what degree your workload involves sync writes? I cannot check that at this moment as my test machine is under a stress test for a different project right now, but should be able to over the weekend. For my workload (and one that easily provokes the problems) sync write I/O is a very large part of the workload on the machine and pools involved as the production systems most-impacted have a Postgres database running on them with very heavy write transaction activity. 793446 192 mikej 2014-10-31 15:38:47 +0000 Are there updates to the patch as it does not apply cleanly to 10.1-PRERELEASE #0 r273834. r273834 still suffers from using swap when under memory pressure. If not, what is the latest version of 10 stable that should be used. Thanks. 793796 193 karl 2014-11-01 13:57:34 +0000 (In reply to mikej from comment #192) > Are there updates to the patch as it does not apply cleanly to > 10.1-PRERELEASE #0 r273834. > > r273834 still suffers from using swap when under memory pressure. > > If not, what is the latest version of 10 stable that should be used. > > Thanks. My test machine is otherwise occupied with a project (as am I) at the moment; I can attempt to refactor my last patch against 10.1-PRERELEASE some time early to mid next-week. My current production kernel with my last patch is built from r272215. 797746 194 mikej 2014-11-24 20:01:54 +0000 Have any of these patches made it into later version of 10-stable, do you still need to patch against r272215 or is there a revised patch available? Thanks! 797845 195 smh 2014-11-25 02:02:26 +0000 (In reply to mikej from comment #194) > Have any of these patches made it into later version of 10-stable, do you > still need to patch against r272215 or is there a revised patch available? Yes the core refactor is in stable/10 as of r272875 however there is still more work to do. 797863 196 rainer 2014-11-25 08:32:00 +0000 What's the status of this patch regarding 10.1? Is this in 10.1? Or is there a patch for 10.1? 797899 197 smh 2014-11-25 13:25:09 +0000 (In reply to rainer from comment #196) > What's the status of this patch regarding 10.1? > > Is this in 10.1? > Or is there a patch for 10.1? It was unfortunately too late to make it into 10.1 but you can use the patch from stable/10 https://svnweb.freebsd.org/base?view=revision&revision=272875 809397 198 karl 2015-02-10 19:57:48 +0000 I have refactored this patch for 10.1-STABLE as it exists today and have initiated testing. Some of the proposed changes are in 10.1 but not all (particularly not dynamic dirty write sizing); the threshold for arc eviction by default is also set too low IMHO (which brings the pager into play when it should not be.) When I have an updated patch that applies cleanly against the -STABLE codebase I'll post it. 809427 199 152852 karl 2015-02-10 21:44:49 +0000 Created attachment 152852 ARC Refactor / UMA Cleardown / DMU_TX dynamic against 10.1-STABLE This has received LIMITED testing here but appears to be fully functional and provides identical behavior to the previous revision. Heavy I/O and compile loads evict cache as memory pressure rises; you should not see swap activity. Applies cleanly against r278524. Dynamic dmu_tx write buffer sizing can be disabled by setting vfs.zfs.dynamic_write_buffer=0 and the free target can be adjusted with vfs.zfs.arc_free_target, both are available dynamically while the system is operating. Write buffer dynamic sizing defaults on and arc_free_target defaults to the pager wakeup threshold plus half the difference between the free target and wakeup threshold. Attachment 147609 above works with this patch to monitor behavior should you desire to do so using dtrace. Comments welcome. 811789 200 karl 2015-02-23 22:35:19 +0000 (In reply to karl from comment #199) The latest has now been running on a production system running FreeBSD 10.1-STABLE #8 r278579M for close to two weeks without incident. 813553 201 seanc 2015-03-05 20:00:53 +0000 Since you're nearly at a month of running this, how has it performed? What are the next steps? We've begun testing and are ramping up load, but haven't seen anything yet. 813560 202 karl 2015-03-05 20:23:11 +0000 (In reply to Sean Chittenden from comment #201) It is running extremely well; I have noted no anomalous behavior at all. I do not believe core's view of this has changed, which means they may not be willing to MFC it but since I cannot run the base code without serious performance problems in my environment I will be maintaining it for (at minimum) the builds I run until it is either MFC'd or becomes unnecessary due to further evolution in the base code set. There is one remaining known issue that can impact interactive response that is in the base code but not really addressed in this patch set, which is dynamic TXG queue management based not on memory size but on volume set performance. The issue here is that it is quite possible for a very large amount of dirty data to be queued for write and clearance of that data to disk may require tens or even *hundreds* of seconds in some cases. Ironically this is most-likely to show up at times of relatively low RAM pressure from other processes but "quick-n-fast" dirtying of data (e.g. "make -j16 buildkernel"), especially with this patch in, as under high RAM pressure the dynamic dmu_tx resizing limits write backlog as part of its memory "breathing" management heuristic. The problem with fixing that in a patch set is that I have not yet identified how to determine a volume set's write I/O performance (e.g. effective throughput available) on a dynamic basis or even if ZFS' code maintains that data internally at all. This is something I would like to fix but it's not high priority as it comes up rarely in my environment. 813780 203 junchoon 2015-03-07 04:22:30 +0000 (In reply to karl from comment #199) Observed no incident running with r278535 through r279579, stable/10 amd64. Notebook with 8GB of RAM. Completely no swap observed within then. Thanks! Note: Performed several updates of base, rebuilding www/chromium, editors/libreoffice (not at the same moment, though) while buildkernel for memory pressure. In some case, performing above while buildkernel of head in VirtualBox VM (1GB of memory allowed). 818262 204 smh 2015-04-03 15:44:07 +0000 The following is a interesting commit from mav which may well have an impact on this: https://svnweb.freebsd.org/base?view=revision&revision=281026 818265 205 karl 2015-04-03 15:50:23 +0000 (In reply to Steven Hartland from comment #204) Mayyybeee.... although it looks like that is likely an additional potential issue, albeit one that with my code changes in is unlikely to manifest (due to the cleanup of UMA and dynamic dmu_tx resize that takes place under memory pressure with sufficient margin before things get out of control.) 824283 206 thomasrcurry 2015-05-17 16:58:35 +0000 karl, thank you so much for your efforts on this issue. I stumbled across this PR a few days ago and after having poured through your detailed research and explanations it has shed light on issues I have been having for quite some time. I'm currently running stable/10 r282909 and I believe the symptoms I'm seeing are related to the problem you describe. Would you agree that at this revision, without your patches, there will be problems with memory reclamation? I have applied your patch and begun testing the IO patterns that led to my numerous kernel panics. So far so good, though I haven't been testing long. I really hope the devs take a look at this patch and incorporate it at some point. Maybe they have in head but it hasn't been merged to stable? I don't know. What I do know is if you use FreeBSD as an iSCSI SAN for VM storage and also use it as a SMB backup target you're going to have a very, very bad time without this patch. 824295 207 karl 2015-05-17 18:22:38 +0000 [[I'm currently running stable/10 r282909 and I believe the symptoms I'm seeing are related to the problem you describe. Would you agree that at this revision, without your patches, there will be problems with memory reclamation?]] I am on 10.1-Stable r278579 with the patch in; I have not updated to later as I've had no real reason to as of this point. The interactions between the VM and what it wants to do, the use of UMA and ZFS' ARC design assumptions all interact in rather interesting ways that "disagree" with each other. This patch isn't an optimal answer as I've noted but it does the job and it appears to provide durable relief for those people who otherwise manage to trigger the bad behavior with their particular operating environment. There is an obscure comment in the first quarter status report that MIGHT relate to this patch -- it's not entirely clear. http://www.freebsd.org/news/status/report-2015-01-2015-03.html 824297 208 rainer 2015-05-17 18:41:55 +0000 I also wondered about that sentence in the report. That discussion must have taken place on the core-mailing list directly. Because I didn't see it in this PR, nor -stable nor -fs. I still have to upgrade my 10.0 system that showed this problem and that I haven't upgraded to 10.1, yet. 824299 209 thomasrcurry 2015-05-17 18:57:16 +0000 It was that comment that sparked my interest and after some googling led me to this PR. I have a feeling it does indeed refer to this discussion. 824329 210 seanc 2015-05-17 23:52:46 +0000 I'm not authoritative, but I believe that comment was related to this issue. 825774 211 seanc 2015-05-28 16:40:34 +0000 Karl, have you run any tests with -STABLE recently after some of these fixes? If so, how are they running? 825776 212 karl 2015-05-28 17:06:07 +0000 (In reply to Sean Chittenden from comment #211) I have been running this code on -STABLE since the last update on a continual basis in production and have recorded no anomalous behavior. One of my busier production systems with this code on it currently has 106 days of uptime and has been completely stable. 825779 213 seanc 2015-05-28 17:18:53 +0000 Alright, good to know. Have you run -STABLE without this patch to see if the fixes from mav@ helped or hindered? 825781 214 karl 2015-05-28 17:23:41 +0000 (In reply to Sean Chittenden from comment #213) No; I have looked at that patch but from reading it I have no reason to believe that it would impact the specific issues this patch attempts to address; I'm not running into the cases where that specific issue becomes a problem in my particular use profiles. 827084 215 thomasrcurry 2015-06-09 10:37:47 +0000 To anyone else running with this patch, have you noticed a dramatic drop in arc hit ratios? Before, as measured with zfs-stats -E, my system seemed to hover around 95% for Cache Hit Ratio and 90% for Actual Hit Ratio. Now these seem quite a bit lower, 89% and 70% respectively right now. Running dtrace for a bit on arc_evict I notice that MFU entries get evicted just as often as MRU. This seems a bit a bit strange, though I'm no expert. I would think MFU entries are valuable and would be held as long as possible, trimming the tail of MRU instead. 827093 216 karl 2015-06-09 12:24:51 +0000 Cache efficiency is a function of both size and workload; I have an extremely write-heavy workload on one of my production machines here (database service with a very high percentage of updates as a percentage of total I/Os) and run around 75% total. On that system the MRU cache list is much larger (85%) than the MFU size (15%) but the MFU list gets most of the hits (77%). ARC Summary: (HEALTHY) Memory Throttle Count: 0 ARC Misc: Deleted: 7.79m Recycle Misses: 2.78m Mutex Misses: 1.35k Evict Skips: 38.83m ARC Size: 67.63% 15.10 GiB Target Size: (Adaptive) 67.77% 15.13 GiB Min Size (Hard Limit): 12.50% 2.79 GiB Max Size (High Water): 8:1 22.33 GiB ARC Size Breakdown: Recently Used Cache Size: 84.63% 12.81 GiB Frequently Used Cache Size: 15.37% 2.33 GiB ARC Hash Breakdown: Elements Max: 1.41m Elements Current: 52.10% 736.74k Collisions: 2.94m Chain Max: 7 Chains: 82.23k ------------------------------------------------------------------------ ARC Efficiency: 111.93m Cache Hit Ratio: 80.42% 90.02m Cache Miss Ratio: 19.58% 21.91m Actual Hit Ratio: 74.24% 83.10m Data Demand Efficiency: 83.86% 76.83m Data Prefetch Efficiency: 8.41% 2.78m CACHE HITS BY CACHE LIST: Anonymously Used: 6.48% 5.83m Most Recently Used: 14.93% 13.44m Most Frequently Used: 77.38% 69.66m Most Recently Used Ghost: 0.15% 132.44k Most Frequently Used Ghost: 1.06% 949.70k CACHE HITS BY DATA TYPE: Demand Data: 71.58% 64.43m Prefetch Data: 0.26% 233.84k Demand Metadata: 20.49% 18.45m Prefetch Metadata: 7.67% 6.90m CACHE MISSES BY DATA TYPE: Demand Data: 56.58% 12.40m Prefetch Data: 11.62% 2.55m Demand Metadata: 16.47% 3.61m Prefetch Metadata: 15.33% 3.36m 830092 217 karl 2015-07-02 19:41:33 +0000 The latest refactor (2015-02-10) appears to apply cleanly against 10.2-PRE with only minor fuzzing (a 10 line offset in one hunk); I am testing it now for functionality. 832181 218 158809 karl 2015-07-15 17:23:24 +0000 Created attachment 158809 ARC Refactor / UMA Cleardown / DMU_TX dynamic against 10.2-BETA1 No difference in expected behavior, makes conforming change to storage class for i386 dynamic linker and fix up offsets. Otherwise unchanged in regard to the previous iteration. 832183 219 karl 2015-07-15 17:24:37 +0000 Patch that applies cleanly against 10.2-BETA1 added; this has seen limited but successful operation on my test machine, but not heavy production use as of yet as I have not yet rolled forward my production machines. 833669 220 159207 junchoon 2015-07-25 05:14:09 +0000 Created attachment 159207 ARC Refactor / UMA Cleardown / DMU_TX dynamic against 10.2-r285717 and later Karl's latest patch no longer applies from r285717, stable/10. By modifying 1 line (line 67), the patch applies cleanly, builds and runs OK. Attached is the modified patch. By the way, although the modified patch applies with some fuzz in head, it doesn't build. Below is the error messages (-j1). I haven't be able to determine which commit missed the declaration of cnt. cc -O2 -pipe -march=nehalem -DFREEBSD_NAMECACHE -DBUILDING_ZFS -fno-strict-aliasing -Werror -D_KERNEL -DKLD_MODULE -nostdinc -I/usr/src/sys/cddl/compat/opensolaris -I/usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs -I/usr/src/sys/cddl/contrib/opensolaris/uts/common/zmod -I/usr/src/sys/cddl/contrib/opensolaris/uts/common -I/usr/src/sys -I/usr/src/sys/cddl/contrib/opensolaris/common/zfs -I/usr/src/sys/cddl/contrib/opensolaris/common -DHAVE_KERNEL_OPTION_HEADERS -include /usr/obj/usr/src/sys/TEST12/opt_global.h -I. -I/usr/src/sys -fno-common -g -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -I/usr/obj/usr/src/sys/TEST12 -mcmodel=kernel -mno-red-zone -mno-mmx -mno-sse -msoft-float -fno-asynchronous-unwind-tables -ffreestanding -fwrapv -fstack-protector -gdwarf-2 -Wall -Wredundant-decls -Wnested-externs -Wstrict-prototypes -Wmissing-prototypes -Wpointer-arith -Winline -Wcast-qual -Wundef -Wno-pointer-sign -D__printf__=__freebsd_kprintf__ -Wmissing-include-dirs -fdiagnostics-show-option -Wno-unknown-pragmas -Wno-error-tautological-compare -Wno-error-empty-body -Wno-error-parentheses-equality -Wno-error-unused-function -Wno-error-pointer-sign -Wno-missing-prototypes -Wno-undef -Wno-strict-prototypes -Wno-cast-qual -Wno-parentheses -Wno-redundant-decls -Wno-missing-braces -Wno-uninitialized -Wno-unused -Wno-inline -Wno-switch -Wno-pointer-arith -mno-aes -mno-avx -std=iso9899:1999 -include /usr/src/sys/cddl/compat/opensolaris/sys/debug_compat.h -c /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c -o arc.o /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c:226:53: error: use of undeclared identifier 'cnt'; did you mean 'int'? zfs_arc_free_target = vm_pageout_wakeup_thresh + ((cnt.v_free_target - vm_pageout_wakeup_thresh) / 2); ^~~ int /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c:226:53: error: expected expression /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c:2995:29: error: use of undeclared identifier 'cnt' if (zio_use_uma && (ptob(cnt.v_free_count) + size < ptob(cnt.v_free_target))) { ^ /usr/src/sys/cddl/compat/opensolaris/sys/param.h:38:30: note: expanded from macro 'ptob' #define ptob(x) ((uint64_t)(x) << PAGE_SHIFT) ^ /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c:2995:61: error: use of undeclared identifier 'cnt' if (zio_use_uma && (ptob(cnt.v_free_count) + size < ptob(cnt.v_free_target))) { ^ /usr/src/sys/cddl/compat/opensolaris/sys/param.h:38:30: note: expanded from macro 'ptob' #define ptob(x) ((uint64_t)(x) << PAGE_SHIFT) ^ /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c:2996:48: error: use of undeclared identifier 'cnt'; did you mean 'int'? DTRACE_PROBE3(arc__alloc_lowmem_reap, int, cnt.v_free_count, int, size, int, cnt.v_free_target); ^~~ int /usr/src/sys/sys/sdt.h:345:32: note: expanded from macro 'DTRACE_PROBE3' DTRACE_PROBE_IMPL_START(name, arg0, arg1, arg2, 0, 0) \ ^ /usr/src/sys/sys/sdt.h:326:27: note: expanded from macro 'DTRACE_PROBE_IMPL_START' SDT_PROBE(sdt, , , name, arg0, arg1, arg2, arg3, arg4); ^ /usr/src/sys/sys/sdt.h:166:19: note: expanded from macro 'SDT_PROBE' (uintptr_t) arg0, (uintptr_t) arg1, (uintptr_t) arg2, \ ^ /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c:2996:48: error: expected expression /usr/src/sys/sys/sdt.h:345:32: note: expanded from macro 'DTRACE_PROBE3' DTRACE_PROBE_IMPL_START(name, arg0, arg1, arg2, 0, 0) \ ^ /usr/src/sys/sys/sdt.h:326:27: note: expanded from macro 'DTRACE_PROBE_IMPL_START' SDT_PROBE(sdt, , , name, arg0, arg1, arg2, arg3, arg4); ^ /usr/src/sys/sys/sdt.h:166:19: note: expanded from macro 'SDT_PROBE' (uintptr_t) arg0, (uintptr_t) arg1, (uintptr_t) arg2, \ ^ /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c:2996:82: error: use of undeclared identifier 'cnt'; did you mean 'int'? DTRACE_PROBE3(arc__alloc_lowmem_reap, int, cnt.v_free_count, int, size, int, cnt.v_free_target); ^~~ int /usr/src/sys/sys/sdt.h:345:44: note: expanded from macro 'DTRACE_PROBE3' DTRACE_PROBE_IMPL_START(name, arg0, arg1, arg2, 0, 0) \ ^ /usr/src/sys/sys/sdt.h:326:39: note: expanded from macro 'DTRACE_PROBE_IMPL_START' SDT_PROBE(sdt, , , name, arg0, arg1, arg2, arg3, arg4); ^ /usr/src/sys/sys/sdt.h:166:55: note: expanded from macro 'SDT_PROBE' (uintptr_t) arg0, (uintptr_t) arg1, (uintptr_t) arg2, \ ^ /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c:2996:82: error: expected expression /usr/src/sys/sys/sdt.h:345:44: note: expanded from macro 'DTRACE_PROBE3' DTRACE_PROBE_IMPL_START(name, arg0, arg1, arg2, 0, 0) \ ^ /usr/src/sys/sys/sdt.h:326:39: note: expanded from macro 'DTRACE_PROBE_IMPL_START' SDT_PROBE(sdt, , , name, arg0, arg1, arg2, arg3, arg4); ^ /usr/src/sys/sys/sdt.h:166:55: note: expanded from macro 'SDT_PROBE' (uintptr_t) arg0, (uintptr_t) arg1, (uintptr_t) arg2, \ ^ 8 errors generated. *** [arc.o] Error code 1 make[4]: stopped in /usr/src/sys/modules/zfs 1 error make[4]: stopped in /usr/src/sys/modules/zfs *** [all_subdir_zfs] Error code 2 make[3]: stopped in /usr/src/sys/modules 1 error make[3]: stopped in /usr/src/sys/modules *** [modules-all] Error code 2 make[2]: stopped in /usr/obj/usr/src/sys/TEST12 1 error make[2]: stopped in /usr/obj/usr/src/sys/TEST12 *** [buildkernel] Error code 2 make[1]: stopped in /usr/src 1 error make[1]: stopped in /usr/src *** [buildkernel] Error code 2 make: stopped in /usr/src 1 error make: stopped in /usr/src 833787 221 karl 2015-07-26 12:06:10 +0000 I'm looking at this now against 10.2-RC.... will update it sometime today. I have not attempted to apply it against -HEAD. 834280 222 junchoon 2015-07-29 15:21:07 +0000 I've found the cause of build failure in -head. Global cnt is renamed to vm_cnt by r263620[1][2][3], at Sat Mar 22 10:26:09 2014 UTC. (sys/sys/vmmeter.h and affected files) By replacing all cnt.* to vm_cnt.* in my modified patch, 1)Applicable with some fuzz. 2)Built and boots fine in UFS only VM (VirtualBox). 3)Not tested yet with ZFS environment. Confirmed at r286002. As of 3) above, I've not uploaded modified patch yet. (Will try next weekend, if possible.) But it would be OK because the change in r263620 is, actually, renaming of global variable cnt. [1]https://svnweb.freebsd.org/base?view=revision&revision=263620 [2]https://svnweb.freebsd.org/base/head/sys/sys/vmmeter.h?r1=263620&r2=263619&pathrev=263620 [3]https://svnweb.freebsd.org/base/head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c?r1=263620&r2=263619&pathrev=263620 835221 223 ktk 2015-08-06 14:09:11 +0000 Any chance for an update of the patch for latest 10.1 stable? Checkout I used: /usr/src # svn info Path: . Working Copy Root Path: /usr/src URL: http://svn0.us-east.freebsd.org/base/stable/10 Relative URL: ^/stable/10 Repository Root: http://svn0.us-east.freebsd.org/base Repository UUID: ccf9f872-aa2e-dd11-9fc8-001c23d0bc1f Revision: 286362 Node Kind: directory Schedule: normal Last Changed Author: kib Last Changed Rev: 286362 Last Changed Date: 2015-08-06 10:51:15 +0200 (Thu, 06 Aug 2015) # PATCH /usr/src/sys # patch -i ../zfs-patch-10_1_stable.txt Hmm... Looks like a unified diff to me... The text leading up to this was: -------------------------- |Index: cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c |=================================================================== |--- cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c (revision 278524) |+++ cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c (working copy) -------------------------- Patching file cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c using Plan A... Hunk #1 succeeded at 190. Hunk #2 succeeded at 221. Hunk #3 succeeded at 242. Hunk #4 failed at 2646. Hunk #5 succeeded at 2709 (offset 10 lines). Hunk #6 succeeded at 2728 (offset 10 lines). Hunk #7 succeeded at 2938 (offset 10 lines). 1 out of 7 hunks failed--saving rejects to cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c.rej the error: /usr/src/sys # cat cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c.rej @@ -2635,6 +2646,28 @@ extern kmem_cache_t *zio_data_buf_cache[]; extern kmem_cache_t *range_seg_cache; +static void __used +reap_arc_caches() +{ + size_t i; + kmem_cache_t *prev_cache = NULL; + kmem_cache_t *prev_data_cache = NULL; + + for (i = 0; i < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT; i++) { + if (zio_buf_cache[i] != prev_cache) { + prev_cache = zio_buf_cache[i]; + kmem_cache_reap_now(zio_buf_cache[i]); + } + if (zio_data_buf_cache[i] != prev_data_cache) { + prev_data_cache = zio_data_buf_cache[i]; + kmem_cache_reap_now(zio_data_buf_cache[i]); + } + } + kmem_cache_reap_now(buf_cache); + kmem_cache_reap_now(hdr_cache); + kmem_cache_reap_now(range_seg_cache); +} + static void __noinline arc_kmem_reap_now(arc_reclaim_strategy_t strat) { the rest was fine according to patch. regards Adrian 835226 224 ktk 2015-08-06 14:32:29 +0000 Karl told me to try the latest patch and indeed the one from Tomoaki " ARC Refactor / UMA Cleardown / DMU_TX dynamic against 10.2-r285717 and later" seems to apply! Will see if the weird problems I started having on a new system will disappear with it. 835504 225 159688 junchoon 2015-08-09 11:56:42 +0000 Created attachment 159688 ARC Refactor / UMA Cleardown / DMU_TX dynamic against head after r263620 Patch for head after r263620 (follow renaming of struct cnt). Tested with r286002 in Root-on-ZFS VirtualBox VM (allowing 2 core and 2GB of RAM). Tried buildworld/buildkernel with -j4, amount of swap looks rasonable. (300MB+) *In another VM allowing 2 core and 1GB of RAM, UFS2 installation, same revision, same build option, 2GB swap partition exhausts and require 512MB of swap file. *Swap partition of Root-on-ZFS VM is 2GB, same as UFS2 one. So patched Root-on-ZFS looks more aggressively frees cache (arc) than UFS2. *UFS2 installation shows severe thrashing behavior. I tried to create Root-on-ZFS memstick to test with real hardware, but no success. Maybe memstick problem (reused memstick). So I decided to upload patch for head for someone can test. The only differense with former one is only to rename cnt to vm_cnt. stable/10 user must use former one. Simple port, but hope this catches more FreeBSD developer's eyes. 835505 226 junchoon 2015-08-09 12:02:28 +0000 (In reply to Adrian Gschwend from comment #224) FYI, stable/10 r286399 with the patch, amd64, is running fine for me. 835507 227 junchoon 2015-08-09 12:14:03 +0000 (In reply to Tomoaki AOKI from comment #225) I guess 2GB of RAM is too small for ZFS environment, but giving more RAM for VM is not acceptable on 8GB notebook. :-( So I had to compare amount of swap against UFS2 one. *The highest memory pressure happenes when building clang, in toolchain phase, and real build phase. 836276 228 159859 junchoon 2015-08-14 15:36:37 +0000 Created attachment 159859 ARC Refactor / UMA Cleardown / DMU_TX dynamic against head after r286570 Almost just after I uploaded former patch for -head, massive updates are made to -head. Unfortunately, former patch (patch.head.r263620) is not applicable after r286570 [1]. I created revised patch (now applicable on /usr/src) , but current state is... *Confirmed applicable to head r286718, which massive update seems to be ended. [With some fuzz, not fixed] *builds, installs and boots fine for environment below. *VirtualBox VM allowed 2GB of RAM and 2 cores of CPU. *ZFS-root by bsdinstall, single drive, 2GB of swap partition outside ZFS pool. */tmp in ZFS pool (default). not swap backed /tmp. *After installworld and reboot, tested with a couple of buildkernel, runs as usual, but with about 1MB of swap at ctfmerge after linking. *Not tested with l2arc, which SHALL need testing as of r286570 commit message. Yes, 2GB of memory is tooo small to run ZFS environment. But it's the maximum I can give to VM for now. :-( This is all what I can (at least for now). I should hand over to someone familiar with VM, ZFS, and -head codes. In general, FreeBSD src codes are first tested with patch(es) on head, merged to head, and then MFC'ed. In other hand, Karl's work is proceeded on stable/10 (or 10.x-Release branch), as it's needed for his production system and shares to us. So if we want it land to src, we need someone else to port his patch(es) to head. I would be able to make initial port to head like this, but enough level of reviews and tests on wide variety of environments would be strongly needed. It's clearly beyond my hand. <Technical (a bit) details and concerns> In r286570 changes, hdr_cache is splitted into hdr_full_cache and hdr_l2only_cache. See line 1099-1100, 1112-1113, 1239-1243, 3026-3027 in [1] for detail. In r286625 changes, arc_kmem_reap_now() no longer has any argument. See line 3279 in [2] for detail. Although I cannot confirm enough, It can indirectly prevent this patch from actually working. Isn't it? Also in r286625 changes, condition in line 3339 to 3340 is changed to use arc_available_memory() instead of arc_reclaim_needed(). There's more changes in same function. Would it affect? See [2]. And possibly many others I'm missing. [1] https://svnweb.freebsd.org/base/head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c?r1=284513&r2=286570 [2] https://svnweb.freebsd.org/base/head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c?r1=286623&r2=286625 836467 229 159905 junchoon 2015-08-15 16:51:55 +0000 Created attachment 159905 ARC Refactor / UMA Cleardown / DMU_TX dynamic against head after r286776 Massive updates again. :-( This would be why Karl doesn't want to develope on head. Previous patch is no longer applicable with latest head. New one should be applicable with r286763 or later. Confirmed to be applicable to r286795, and by tracking commit log, breaking commit was r286763. See line 3529 to 3540, 3793 to 3800 in [1]. *Beware! Line 3795 matches 7th line in line 3799 block of left side. "} else {" in line 3795 of right side shall match 8th line in line 3799 block of left side. Line numbers shown in leftmost is matched to right side. Latest commit to arc.c is r286776 now, so latest patch is named need_test-patch.head.r286776. Porting level is as previous one. (initial level) This time, I regenerated patch using svnlite diff, so no more fuzz, if you apply to r286776 through r286795. Instead, function name in @@ lines are lost. This time, I obsoleted my old patches for head. If you need old ones with some needs, try "Show obsolete". Patches for stable/10 aren't obsoleted. [1] https://svnweb.freebsd.org/base/head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c?r1=286762&r2=286763 839748 230 fk 2015-09-09 13:47:54 +0000 I've been using Karl's patch for a couple of months now on systems based on 11-CURRENT and clearly it's a big improvement. Unfortunately I still noticed severe latency issues under memory pressure on systems that frequently operate close to the ARC minimum. This patch seems to significantly improve the user experience: https://www.fabiankeil.de/sourcecode/electrobsd/zfs-arc-tuning.diff (Apply Karl's patch first) For details see: https://www.fabiankeil.de/gehacktes/electrobsd/zfs-arc-tuning/ 839761 231 karl 2015-09-09 14:07:25 +0000 I like that in general; that's yet another piece of the puzzle..... Will look into incorporating it. 842773 232 161691 junchoon 2015-10-04 11:51:18 +0000 Created attachment 161691 ARC Refactor / UMA Cleardown / DMU_TX dynamic against stable/10 after r288599 Afrer massive MFCs from r288516 to r288599 by Alexander Motin (mav@), Karl's most recent patch with my fix (for r285717) no longer applies. Unfortunately, my ported patch for head applies, but doesn't build because global struct cnt to vm_cnt change (I noted it in Comment 222) isn't MFC'ed yet. (Maybe never MFC'ed because of KPI/KBI change.) But fortunately, replacing all 'vm_cnt' in the patch to 'cnt' helps. One more news. Fabian Keil's incremental patch (with replacing all 'vm_cnt' in the patch to 'cnt') is now applicable for stable/10. Updated patch applied together with Fabian Keil's incremental patch is running fine for me (stable/10 r288599, amd64), but not yet heavy-loaded. (Compiling www/chromium with memory pressure by VirtualBox VM is on-going.) 842774 233 161692 junchoon 2015-10-04 12:00:55 +0000 Created attachment 161692 ARC Refactor / UMA Cleardown / DMU_TX dynamic with time-based rate limiting against stable/10 after r288599 Convenient patch for testers who want to test Fabian's patch. Applies Karl's patch (modified for stable/10 after r288599) and Fabian's patch (modified for stable/10) at once. Won't upload modified Fabian's patch alone, as its prerequisite is that Karl's patch is already applied. 842777 234 junchoon 2015-10-04 12:50:26 +0000 (In reply to Tomoaki AOKI from comment #232) Building www/chromium under memory pressure finished earlier than I estimated with relatively small amount of swap. As it finished while I didn't watching top outputs, I couldn't see when the swap occurred and how much free memory ATM. But the fact below would possibly indicate that the memory pressure I gave was too large for phisical memory. (8GB) *The amount of swap was relatively small. (about 187MB) *Mate desktop, firefox, sylpheed, multiple Mate terminal, and some others was running. *VirtualBox VM used for memory pressure is allowed 2GB of memory. *ARC size (below 900MB) was smaller than the size of www/chromium/work (1.1GB), possibly mean no more shrink was possible while linking. *While du for calculating disk usage of www/chromium/work, ARC grew to 1.1GB. 843329 235 karl 2015-10-09 15:08:15 +0000 Testing now on my test machine with the most-recent 10.2-STABLE ZFS changes in..... if it looks ok I will post here and roll forward onto one of my production machines this weekend during my regular maintenance window. 843334 236 fk 2015-10-09 16:11:26 +0000 FYI, I'm currently testing additional patches to limit the inactive memory more aggressively. This should fix two remaining issues I run into: 1) As Andriy predicted, some workloads can result in the ARC getting starved by inactive pages: last pid: 28429; load averages: 0.48, 0.46, 0.41 up 0+03:39:07 17:24:59 91 processes: 2 running, 88 sleeping, 1 waiting CPU: 1.4% user, 0.0% nice, 12.7% system, 0.2% interrupt, 85.7% idle Mem: 396M Active, 489M Inact, 986M Wired, 292K Cache, 5202K Buf, 43M Free ARC: 351M Total, 90M MFU, 44M MRU, 6839K Anon, 7810K Header, 203M Other, 350M Target Swap: 2048M Total, 99M Used, 1949M Free, 4% Inuse PID USERNAME THR PRI NICE SIZE RES STATE C TIME WCPU COMMAND 11 root 2 155 ki31 0K 32K RUN 0 377:37 170.34% idle 26625 fk 17 36 0 175M 24504K uwait 1 0:09 8.40% git 0 root 468 -16 0 0K 7488K swapin 1 3:29 6.26% kernel 22 root 1 20 - 0K 16K geli:w 1 4:16 5.06% g_eli[1] ada0s1d 2015 Sep 21 17:24:58: Scan goals in the previous minute: Update active LRU/deactivate pages 60 2015 Sep 21 17:24:58: Seconds since last 'Move inactive to cache or free' pass: 1477 2015 Sep 21 17:24:58: Seconds since last 'Launder dirty pages' pass: 9273 2) On systems with only 1 GB of RAM and no ZFS tuning, memory pressure sometimes causes the free pages to shrink to v_interrupt_free_min (2!) because the inactive pages aren't freed quickly enough. As a result, ZFS locks up and the system panics or merely becomes unresponsive (except for ICMP etc.). I initially suspected that this was a result of my rate-limiting patch, but disabling the rate limit in case of vm_page_count_min() didn't make a difference. This could be a completely unrelated issue and I have not yet tried to reproduce it with vanilla FreeBSD. As I have not been able to reproduce the problem on systems with 2 GB or more, I continue to use the patches in production. Anyway, first results look promising and I intend to polish and publish the patches in a couple of days. 843478 237 karl 2015-10-10 16:05:51 +0000 I'm very interested in looking at that; I played with some code that looked at the inact list when it was larger than the target and woke the vm system up to run through its demotion/cleaning routine. It did the desired thing more-or-less (and resulted in more ARC memory) but there's a potential price for that, in that the reason for inact pages is to avoid I/O in the event that a page that was previously in use is again referenced. It was not clear to me from my benchmarking that the code addition was actually beneficial in this instance, particularly with moderate RAM configurations..... are you triggering only when the ARC target size is less than the max high-water size? 843484 238 karl 2015-10-10 17:40:07 +0000 Here is what I am playing with at present.... If we come through the consider_reap routine, wake the pager. But, since there's an event handler for "low memory" in the arc code that will get triggered if the pager wakes up, set a (local) flag so as to not run through there if we woke the pager up, while leaving it active if the VM system woke up on its own. (Without that test the ARC get slammed immediately to the min value and remains there since the event handler will get fired immediately when the pager is awakened.) This *should* leave inact pages alone (which is desirable) until and unless we have a reason to reap, but when we do it should also force the pager to wake up and go through the process for demoting inact pages that have aged sufficiently, even though the pager is otherwise happy with the state of the system. My initial tests appear to say this works as expected, and it's low-impact. I'm running a soak right now to see if performance bears up under some fairly extreme circumstances. 843488 239 karl 2015-10-10 18:19:29 +0000 Meh. This does keep inact under control but it also winds up sending some modest number of pages to swap, and the impact on interactive response, particularly if you have a process that has been idle but is still attached to a terminal, is unacceptable when you try to come back to it. 843499 240 karl 2015-10-10 20:13:18 +0000 Another attempt in the same general vein being made.... this one looks more-promising. I've got it on a production box now as it's the weekend and I can get away with it given that it passed on my test machine, so we'll see. It's only a couple of line of code change compared against the latest up above, and if it's effective on those workloads where inact pages pile up then that would be the remaining complaint that has been leveled against this patch. 843559 241 fk 2015-10-11 13:14:33 +0000 I let the vm pageout daemon limit the inactive pages so the ARC can continue to be oblivious of them. In my opinion the ARC has too much knowledge about the vm internals already. Here's a sneak preview: https://www.fabiankeil.de/sourcecode/electrobsd/vm-limit-inactive-memory-more-aggressively.diff (The code has not been properly tested yet!) A screen shot of the inactive page limit in action: https://www.fabiankeil.de/bilder/electrobsd/kernel-compilation-with-inactive-page-limit-enabled.png 843652 242 karl 2015-10-12 12:37:01 +0000 There was an intentional decision taken quite a long time ago when it comes to the VM and inactive pages; in the absence of memory pressure there's no reason to demote (and ultimately evict) them because there is no "cost" in keeping them around, and there might be a benefit if they become active again. I'm not sure changing that is necessarily a good idea although the debate probably ought to be entertained. Note that the original Illumos/Sun code says the following (which only is operative on Solaris): /* * check that we're out of range of the pageout scanner. It starts to * schedule paging if freemem is less than lotsfree and needfree. * lotsfree is the high-water mark for pageout, and needfree is the * number of needed free pages. We add extra pages here to make sure * the scanner doesn't start up while we're freeing memory. */ This is important; the original intent is to remain clear of the pager with ARC's demands. That was what drove the patch in the first place. While the workloads I have accessible to me don't cause inact pages to cause trouble there are reports that for some other people they do. That's easily addressed without changing how VM behaves because the VM system *sleeps* whenever it is not under memory pressure. That is, it never demotes pages under that scenario because it doesn't think there's a reason for it. So what I've been testing here for a little bit is a small change to that paradigm. At a small margin above arc_free_target *wake the pager occasionally* which will cause it to age pages even though it knows that it's not in critical memory trouble. There are two conditions on this test -- first, the init code has to have been run first, because if you wake the pager before the VM's swapper has been initialized the kernel will panic immediately and second, there's no reason to do it until the ARC cache is warmed up. Finally, the ARC code has an event handler set that gets kicked whenever the pagedaemon normally wakes up (which is a statement that we're in memory trouble) and since we're triggering it otherwise under light RAM pressure I've added a bypass so we don't pare arc back in that instance. There are two tunables added to control this behavior: vfs.zfs.arc_wakeup_delay: 500 vfs.zfs.arc_wakeup_pager: 95970 arc_wakeup_delay is the minimum delay in milliseconds between wakes; because waking the pager is expensive in relative terms you don't want to "storm" it. Further, there's no benefit to doing so since the entire (and only) purpose is to allow it to schedule page demotion, particularly from inact. arc_wakeup_pager is the number of pages of free RAM below which we wake the pager up on the above timed schedule. The default is 10/9ths of arc_free_target although you can change it at any time. This has held inact pages to roughly the same as or less than the active count under both synthetic and operational loads; without it inact pages could rise as high as 2-2.5x active under some conditions here, although I never got the "runaway" scenario under the workloads that I have. The price of this change is that it also comes with the *cost* of demoting some pages to swap; I believe there's a cogent argument to be made that this is *wrong* and may hurt interactive performance, perhaps badly, especially where the swap resides on spinning rust. For this reason I'm not sure I like the patch's results, but for those who want to play with it, here it is. (You can effectively disable the wakeup code by setting zfs.vfs.arc_wakeup_pager to vm.v_free_min should you wish to do so on a running system.) 843653 243 161943 karl 2015-10-12 12:40:33 +0000 Created attachment 161943 Patch for 10.2-STABLE r289078 including pagedaemon wakeup code Explained in comment #242; excerpt: Here is a small change to the former patch paradigm. At a small margin above arc_free_target *wake the pager occasionally* which will cause it to age pages even though it knows that it's not in critical memory trouble. There are two conditions on this test -- first, the init code has to have been run first, because if you wake the pager before the VM's swapper has been initialized the kernel will panic immediately and second, there's no reason to do it until the ARC cache is warmed up. Finally, the ARC code has an event handler set that gets kicked whenever the pagedaemon normally wakes up (which is a statement that we're in memory trouble) and since we're triggering it otherwise under light RAM pressure I've added a bypass so we don't pare arc back in that instance. There are two tunables added to control this behavior: vfs.zfs.arc_wakeup_delay: 500 vfs.zfs.arc_wakeup_pager: 95970 arc_wakeup_delay is the minimum delay in milliseconds between wakes; because waking the pager is expensive in relative terms you don't want to "storm" it. Further, there's no benefit to doing so since the entire (and only) purpose is to allow it to schedule page demotion, particularly from inact. arc_wakeup_pager is the number of pages of free RAM below which we wake the pager up on the above timed schedule. The default is 10/9ths of arc_free_target although you can change it at any time. This has held inact pages to roughly the same as or less than the active count under both synthetic and operational loads; without it inact pages could rise as high as 2-2.5x active under some conditions here, although I never got the "runaway" scenario under the workloads that I have. The price of this change is that it also comes with the *cost* of demoting some pages to swap; I believe there's a cogent argument to be made that this is *wrong* and may hurt interactive performance, perhaps badly, especially where the swap resides on spinning rust. For this reason I'm not sure I like the patch's results, but for those who want to play with it, here it is. (You can effectively disable the wakeup code by setting zfs.vfs.arc_wakeup_pager to vm.v_free_min should you wish to do so on a running system.) 846829 244 fk 2015-11-01 16:35:24 +0000 In comment #225 I mentioned ZFS lockups on patched systems with 1 GB of RAM. Just for the record: I recently tried to reproduce them with unpatched FreeBSD 10.2-RELEASE and with a 11.0-CURRENT snapshot based on r289846 (to rule out a regression in HEAD) but the systems remained stable for days with the workload (reproducing ElectroBSD images in a loop) that causes patched systems to panic within hours (sometimes minutes). So far I'm pleased with the patch I posted in comment #241 but intend to add auto-tuning in the near future. I have not yet tried Karl's latest patch but like to point out that some of the underlying assumptions about how the vm pager behaves seem incorrect to me. For example I'd expect calling pagedaemon_wakeup() without memory pressure (from the pagers point of view) to be pretty close to a nop as vm_pageout_worker() does its own checks before doing any heavy lifting: http://fxr.watson.org/fxr/source/vm/vm_pageout.c#L1634 Also note that vm_pageout_worker() is already called at least once per second anyway: [fk@polizei-erziehung ~]$ sudo /usr/src/share/dtrace/monitor-page-scanner 2015 Nov 1 17:20:45: Monitoring the page scanner. Minimum pass value to show 'boring' scans without memory pressure or inactive page surplus: 2 (Launder dirty pages). Press CTRL-C to abort. 2015 Nov 1 17:21:45: Scan goals in the previous minute: Update active LRU/deactivate pages 60 2015 Nov 1 17:22:45: Scan goals in the previous minute: Update active LRU/deactivate pages 60 I'm not claiming that increasing the frequency when there's no memory pressure causes any harm (besides code complexity), but I'm not convinced that it has the intended effect and needs to be triggered from ZFS (as opposed to changing the pager defaults). 850079 245 mikej 2015-11-20 23:28:49 +0000 Can someone please comment on which diff and it's location is currently being tested on both 10-STABLE and HEAD with SVN revision numbers. Acknowledgements on what if any work has been already included in STABLE or HEAD would be enlightening - I don't grep/awk the SVN repository well :-( Karl, Steve and the group thank you for you work and insight. Kind regards, --mikej 850082 246 karl 2015-11-20 23:44:58 +0000 My last set of patches will apply against -STABLE r289078; I have not attempted it against -HEAD. 853056 247 164051 karl 2015-12-10 15:48:51 +0000 Created attachment 164051 Update of patch related to other bug report (see comment for details) Identical to 161943 but adds defense against inversion of the dirty/dirty_max_internal relationship resulting in a potential sign extension or divide-by-zero. In response to https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=205163; the stack backtrace and examination of variables shows inversion of that relationship but the claimed panic cause (integer divide by zero) is not evident in the kernel state, which appears to imply a crashed stack. The code added should in theory never execute and inversion of those values should be impossible because at line ~1325 in dmu_tx.c once dirty_data_max_internal is (potentially) resized dmu_tx_try_assign executes and, if the dirty data level is at or near the (now possibly resized) dirty_data_max amount dmu_tx_wait is called to suspend allocation until that buffer drains. That is, changes in this value are at least theoretically protected against the dirty value meeting or exceeding the resized amount and thus division by zero or an inversion should not be able to happen. Nonetheless it cannot do harm to defend against this (other than the couple of additional instructions and time to execute them) and if it resolves the panic that implies there is a missing mutex somewhere in the base code that needs to be run down and found since it will likely cause trouble elsewhere as well. 895315 248 174197 karl 2016-08-29 17:24:13 +0000 Created attachment 174197 First cut against 11.0-STABLE I have implemented a quick cut of the former patch against 11.0-STABLE @ r305004. This implements only one piece of the 10.x patch heuristic -- the component that senses low memory before the the paging threshold is reached (which is where the base code initiates both ARC eviction *and* paging) and (1) wakes the pager and (2) reaps caches, both with a timer so as to prevent calling these routines (which can be expensive) too rapidly. This cut does *not* bring over the arc_free_target modification from the base code that is in the 10.x patch. 11.x has materially-different internals in a few subtle but potentially important areas when it comes to ARC memory management and its interaction with the VM. However, the stock code has been observed on my production systems to retain some (but not all) of the pathology in 10.x. As such I am being conservative with pulling the patch across to 11.x rather than simply slam-bang porting over the older patch, as minimalism, if it's effective, is a win. This has received minor testing here thus far and while it appears to be quite effective in mitigating some of the remaining bogons in the ARC code I cannot vouch for it at this time in a production environment. Due to limited testing at this point it should be deployed with some care; I am very interested in commentary from others who have issues with memory management (particularly high page file consumption when under memory pressure and/or inappropriate ARC eviction) under memory pressure scenarios as to whether this helps or (hopefully not!) has undesirable side effects. 895316 249 174198 karl 2016-08-29 17:36:05 +0000 Created attachment 174198 Dtrace script to track code execution in above patch against 11.0-STABLE This script, fed to dtrace, will print when the above patch both wakes the pager and executes UMA reaping should you desire to see how often the code in question actually executes 895419 250 karl 2016-08-30 13:46:52 +0000 The 11.0 code is not effective in preventing RSS page eviction to the swap, but *is* effective at preventing ARC pare-back in an inappropriate fashion in my testing thus far. I'm going to tweak vfs.zfs.arc_free_target and see if that's sufficient to stop the aggressive RSS eviction before continuing to bring over the other components of the original patch. I suspect a relatively-minor change in that regard may be effective given what I'm seeing with dtrace. 895477 251 174231 karl 2016-08-30 20:23:02 +0000 Created attachment 174231 Second cut against 11.0-STABLE Second cut; makes the following changes in addition to the above: 1. Sets arc_free_target's default to slightly above the paging threshold instead of equal to it. (This remains tunable if you don't like the defaults.) 2. When the system invades vm.v_free_target (note: still above arc_free_target by a decent amount, especially on larger systems) we start *slowly* cleaning up UMA; one zone is chased down per 500ms "window" on a rotary basis. (For future: I will be looking into the "vmstat" code to see how to determine the "in use" .vs. "free" count and targeting only those UMA buckets where a "material" [e.g. more than 10%?] of the allocated is free and unused in this circumstance.) 3. If we detect an invasion of arc_free_target then the previous algorithm (aggressively clearing down UMA) is employed. The code is a bit rough on a style basis but should be ok execution wise. As with the previous rev this has been tested modestly here without ill effect, but is not guaranteed ok -- use with care, especially on a production machine. The Dtrace script has been updated to show whether the non-aggressive or aggressive reclaim fires, and the former appears to be very effective in limiting the need for the latter to be executed. Evaluation continues. 895478 252 174232 karl 2016-08-30 20:24:09 +0000 Created attachment 174232 Dtrace script to go with Second Cut on 11-STABLE Pairs with the Second Cut 174231 895580 253 174254 karl 2016-08-31 15:00:37 +0000 Created attachment 174254 Cleanup of second patch - no functional changes Remove extraneous call pass-through; no functional change. 896017 254 junchoon 2016-09-04 08:07:07 +0000 (In reply to karl from comment #253) Glad to know you're working on this for stable/11. :-) This is still a important work on stable/11 (and would be head,too). There was only my quick conversion for slightly old patchset for those environments. (Worked mostly OK but observed some strange swaps.) One thing to note. Your new default for vfs.zfs.arc_free_target (even of second cut) looks too small, while old default (for stable/10) works mostly well for me. *Tested old default by manually setting vfs.zfs.arc_free_target in sysctl.conf. Sorry, no DTRACE logs is kept for second cut itself. Currently, I observed swap with old default when a few MB of tmpfs (swap-backed) is used. This should be a known-to-be-OK behaviour. My environment is not changed, except that base is upgraded from stable/10 to stable/11 and rebuilt all ports. 896074 255 karl 2016-09-04 13:41:31 +0000 I am playing with the arc_free_target number here..... with it set where it is now I do get a fair amount of page-space allocation even though RAM is not exhausted, but it doesn't have a notable performance impact. One of the tests I intend to run is to intentionally remove the page allocation from the system when under said load and see if it misbehaves; if not, then perhaps leaving it where it is in the second cut is ok, otherwise I will increase the default. So far the second cut appears to be behaving well on my production machines; I have made a couple of additional cleanup passes on the code itself, but still am looking for the means to determine UMA occupancy for a slab. Not having it isn't critical but it would make the clean-up under light memory pressure more efficient by avoiding calls to reap on zones that have few resources out-but-unused. The exposed public functions documented in the man pages only return the current allocation which is insufficient. 925542 256 avg 2017-03-12 09:56:39 +0000 Can this bug be closed already? I'd suggest opening new, more focused bug reports for any remaining issues. 925588 257 karl 2017-03-12 16:54:16 +0000 The current patch is still running on my 11-STABLE system, the problems still remain if I attempt to run a kernel "neat" without it. While the scope has narrowed to a material degree due to improvements in the base code it's not by any means "fixed" in my opinion in the code "as-shipped" in the 11-STABLE branch. 933349 258 vsasjason 2017-05-08 21:23:44 +0000 Which patch shoud I try for releng/10.3? 933427 259 karl 2017-05-09 14:29:19 +0000 (In reply to Anton Sayetsky from comment #258) See what rev the code is (uname -a) and if the rev is after 288599 try this one: https://bugs.freebsd.org/bugzilla/attachment.cgi?id=164051 If it applies cleanly it should work -- but do check to see if it applies cleanly before committing it! 933797 260 vsasjason 2017-05-12 13:50:05 +0000 (In reply to karl from comment #259) Thanks Karl - patch applied cleanly, buildkernel was fine too. Machine already running patched kernel and you can see zfs-stats output after 16 hours below: root@cs0:~# zfs-stats -a ------------------------------------------------------------------------ ZFS Subsystem Report Fri May 12 16:47:25 2017 ------------------------------------------------------------------------ System Information: Kernel Version: 1003000 (osreldate) Hardware Platform: amd64 Processor Architecture: amd64 ZFS Storage pool Version: 5000 ZFS Filesystem Version: 5 FreeBSD 10.3-RELEASE-p19 #0 r318183M: Thu May 11 23:59:27 MSK 2017 root 16:47 up 16:34, 4 users, load averages: 0,62 0,56 0,53 ------------------------------------------------------------------------ System Memory: 0.01% 19.10 MiB Active, 0.27% 684.19 MiB Inact 94.08% 234.63 GiB Wired, 0.00% 3.88 MiB Cache 5.64% 14.07 GiB Free, 0.00% 0 Gap Real Installed: 256.00 GiB Real Available: 99.98% 255.95 GiB Real Managed: 97.43% 249.39 GiB Logical Total: 256.00 GiB Logical Used: 94.24% 241.26 GiB Logical Free: 5.76% 14.74 GiB Kernel Memory: 1.33 GiB Data: 99.04% 1.32 GiB Text: 0.96% 13.08 MiB Kernel Memory Map: 249.39 GiB Size: 92.55% 230.80 GiB Free: 7.45% 18.58 GiB ------------------------------------------------------------------------ ARC Summary: (HEALTHY) Memory Throttle Count: 0 ARC Misc: Deleted: 1.44m Recycle Misses: 0 Mutex Misses: 114 Evict Skips: 322 ARC Size: 92.76% 230.41 GiB Target Size: (Adaptive) 92.76% 230.40 GiB Min Size (Hard Limit): 77.30% 192.00 GiB Max Size (High Water): 1:1 248.39 GiB ARC Size Breakdown: Recently Used Cache Size: 45.72% 105.35 GiB Frequently Used Cache Size: 54.28% 125.06 GiB ARC Hash Breakdown: Elements Max: 2.37m Elements Current: 100.00% 2.37m Collisions: 157.32k Chain Max: 3 Chains: 78.14k ------------------------------------------------------------------------ ARC Efficiency: 41.19m Cache Hit Ratio: 35.56% 14.65m Cache Miss Ratio: 64.44% 26.54m Actual Hit Ratio: 35.42% 14.59m Data Demand Efficiency: 80.54% 14.41m CACHE HITS BY CACHE LIST: Most Recently Used: 65.55% 9.60m Most Frequently Used: 34.05% 4.99m Most Recently Used Ghost: 0.32% 46.65k Most Frequently Used Ghost: 0.45% 66.17k CACHE HITS BY DATA TYPE: Demand Data: 79.20% 11.60m Prefetch Data: 0.00% 0 Demand Metadata: 19.17% 2.81m Prefetch Metadata: 1.63% 239.14k CACHE MISSES BY DATA TYPE: Demand Data: 10.56% 2.80m Prefetch Data: 0.00% 0 Demand Metadata: 89.21% 23.68m Prefetch Metadata: 0.23% 62.38k ------------------------------------------------------------------------ L2 ARC Summary: (HEALTHY) Passed Headroom: 119.58k Tried Lock Failures: 11.52k IO In Progress: 0 Low Memory Aborts: 0 Free on Write: 226 Writes While Full: 8.66k R/W Clashes: 0 Bad Checksums: 0 IO Errors: 0 SPA Mismatch: 142.53m L2 ARC Size: (Adaptive) 1.09 TiB Header Size: 0.01% 111.71 MiB L2 ARC Breakdown: 26.54m Hit Ratio: 0.70% 186.42k Miss Ratio: 99.30% 26.35m Feeds: 67.06k L2 ARC Buffer: Bytes Scanned: 58.44 TiB Buffer Iterations: 67.06k List Iterations: 265.86k NULL List Iterations: 2 L2 ARC Writes: Writes Sent: 100.00% 31.97k ------------------------------------------------------------------------ ------------------------------------------------------------------------ VDEV cache is disabled ------------------------------------------------------------------------ ZFS Tunables (sysctl): kern.maxusers 16717 vm.kmem_size 267777855488 vm.kmem_size_scale 1 vm.kmem_size_min 0 vm.kmem_size_max 1319413950874 vfs.zfs.trim.max_interval 1 vfs.zfs.trim.timeout 30 vfs.zfs.trim.txg_delay 32 vfs.zfs.trim.enabled 0 vfs.zfs.vol.unmap_enabled 1 vfs.zfs.vol.mode 1 vfs.zfs.version.zpl 5 vfs.zfs.version.spa 5000 vfs.zfs.version.acl 1 vfs.zfs.version.ioctl 5 vfs.zfs.debug 0 vfs.zfs.super_owner 0 vfs.zfs.sync_pass_rewrite 2 vfs.zfs.sync_pass_dont_compress 5 vfs.zfs.sync_pass_deferred_free 2 vfs.zfs.zio.exclude_metadata 0 vfs.zfs.zio.use_uma 1 vfs.zfs.cache_flush_disable 0 vfs.zfs.zil_replay_disable 0 vfs.zfs.min_auto_ashift 12 vfs.zfs.max_auto_ashift 13 vfs.zfs.vdev.trim_max_pending 10000 vfs.zfs.vdev.bio_delete_disable 0 vfs.zfs.vdev.bio_flush_disable 0 vfs.zfs.vdev.write_gap_limit 4096 vfs.zfs.vdev.read_gap_limit 32768 vfs.zfs.vdev.aggregation_limit 131072 vfs.zfs.vdev.trim_max_active 64 vfs.zfs.vdev.trim_min_active 1 vfs.zfs.vdev.scrub_max_active 2 vfs.zfs.vdev.scrub_min_active 1 vfs.zfs.vdev.async_write_max_active 10 vfs.zfs.vdev.async_write_min_active 1 vfs.zfs.vdev.async_read_max_active 3 vfs.zfs.vdev.async_read_min_active 1 vfs.zfs.vdev.sync_write_max_active 10 vfs.zfs.vdev.sync_write_min_active 10 vfs.zfs.vdev.sync_read_max_active 10 vfs.zfs.vdev.sync_read_min_active 10 vfs.zfs.vdev.max_active 1000 vfs.zfs.vdev.async_write_active_max_dirty_percent60 vfs.zfs.vdev.async_write_active_min_dirty_percent30 vfs.zfs.vdev.mirror.non_rotating_seek_inc1 vfs.zfs.vdev.mirror.non_rotating_inc 0 vfs.zfs.vdev.mirror.rotating_seek_offset1048576 vfs.zfs.vdev.mirror.rotating_seek_inc 5 vfs.zfs.vdev.mirror.rotating_inc 0 vfs.zfs.vdev.trim_on_init 1 vfs.zfs.vdev.cache.bshift 16 vfs.zfs.vdev.cache.size 0 vfs.zfs.vdev.cache.max 16384 vfs.zfs.vdev.metaslabs_per_vdev 200 vfs.zfs.txg.timeout 10 vfs.zfs.space_map_blksz 4096 vfs.zfs.spa_slop_shift 5 vfs.zfs.spa_asize_inflation 24 vfs.zfs.deadman_enabled 1 vfs.zfs.deadman_checktime_ms 5000 vfs.zfs.deadman_synctime_ms 1000000 vfs.zfs.recover 0 vfs.zfs.spa_load_verify_data 1 vfs.zfs.spa_load_verify_metadata 1 vfs.zfs.spa_load_verify_maxinflight 10000 vfs.zfs.check_hostid 1 vfs.zfs.mg_fragmentation_threshold 85 vfs.zfs.mg_noalloc_threshold 0 vfs.zfs.condense_pct 200 vfs.zfs.metaslab.bias_enabled 1 vfs.zfs.metaslab.lba_weighting_enabled 1 vfs.zfs.metaslab.fragmentation_factor_enabled1 vfs.zfs.metaslab.preload_enabled 1 vfs.zfs.metaslab.preload_limit 3 vfs.zfs.metaslab.unload_delay 8 vfs.zfs.metaslab.load_pct 50 vfs.zfs.metaslab.min_alloc_size 33554432 vfs.zfs.metaslab.df_free_pct 4 vfs.zfs.metaslab.df_alloc_threshold 131072 vfs.zfs.metaslab.debug_unload 0 vfs.zfs.metaslab.debug_load 0 vfs.zfs.metaslab.fragmentation_threshold70 vfs.zfs.metaslab.gang_bang 16777217 vfs.zfs.free_bpobj_enabled 1 vfs.zfs.free_max_blocks -1 vfs.zfs.no_scrub_prefetch 0 vfs.zfs.no_scrub_io 0 vfs.zfs.resilver_min_time_ms 3000 vfs.zfs.free_min_time_ms 1000 vfs.zfs.scan_min_time_ms 1000 vfs.zfs.scan_idle 50 vfs.zfs.scrub_delay 4 vfs.zfs.resilver_delay 2 vfs.zfs.top_maxinflight 288 vfs.zfs.zfetch.array_rd_sz 1048576 vfs.zfs.zfetch.max_distance 8388608 vfs.zfs.zfetch.min_sec_reap 2 vfs.zfs.zfetch.max_streams 24 vfs.zfs.prefetch_disable 1 vfs.zfs.delay_scale 500000 vfs.zfs.delay_min_dirty_percent 60 vfs.zfs.dirty_data_sync 67108864 vfs.zfs.dirty_data_max_percent 10 vfs.zfs.dirty_data_max_max 4294967296 vfs.zfs.dirty_data_max 4294967296 vfs.zfs.max_recordsize 1048576 vfs.zfs.mdcomp_disable 0 vfs.zfs.nopwrite_enabled 1 vfs.zfs.dedup.prefetch 1 vfs.zfs.arc_reap_delay_min 200 vfs.zfs.arc_cache_reapings_skipped 3271 vfs.zfs.l2c_only_size 0 vfs.zfs.mfu_ghost_data_lsize 110572121600 vfs.zfs.mfu_ghost_metadata_lsize 0 vfs.zfs.mfu_ghost_size 110572121600 vfs.zfs.mfu_data_lsize 135099494912 vfs.zfs.mfu_metadata_lsize 520443392 vfs.zfs.mfu_size 135810017280 vfs.zfs.mru_ghost_data_lsize 136816527872 vfs.zfs.mru_ghost_metadata_lsize 0 vfs.zfs.mru_ghost_size 136816527872 vfs.zfs.mru_data_lsize 109763704320 vfs.zfs.mru_metadata_lsize 464291840 vfs.zfs.mru_size 110581102080 vfs.zfs.anon_data_lsize 0 vfs.zfs.anon_metadata_lsize 0 vfs.zfs.anon_size 5408768 vfs.zfs.l2arc_norw 1 vfs.zfs.l2arc_feed_again 1 vfs.zfs.l2arc_noprefetch 0 vfs.zfs.l2arc_feed_min_ms 200 vfs.zfs.l2arc_feed_secs 1 vfs.zfs.l2arc_headroom 4 vfs.zfs.l2arc_write_boost 174063616 vfs.zfs.l2arc_write_max 87031808 vfs.zfs.arc_meta_limit 66676028416 vfs.zfs.arc_free_target 922966 vfs.zfs.arc_wakeup_delay 500 vfs.zfs.arc_wakeup_pager 1025517 vfs.zfs.dynamic_write_buffer 1 vfs.zfs.arc_shrink_shift 7 vfs.zfs.arc_average_blocksize 8192 vfs.zfs.arc_min 206158430208 vfs.zfs.arc_max 266704113664 ------------------------------------------------------------------------ root@cs0:~# I'll continue to look how it works. 933798 261 vsasjason 2017-05-12 14:00:13 +0000 BTWm I think it's better to change "Affects only me" field to "Affects some people" in Importance field. 933800 262 karl 2017-05-12 14:09:29 +0000 (In reply to Anton Sayetsky from comment #261) Where that field is set now isn't where I set it when I reported the problem originally, and I have not changed it. 933807 263 feld 2017-05-12 15:37:55 +0000 Updated "importance" field. 933836 264 vsasjason 2017-05-12 22:26:02 +0000 (In reply to karl from comment #259) Unfortunately, patch didn't fix my issue. It's somewhat different to that described in current PR, so I'll open a new one & describe there my problem in detail. As a new round of testing disabled UMA in zio. 944876 265 junchoon 2017-07-29 01:00:17 +0000 Not yet looked in enough, but this review looks related. D7538 Correct adaptation ZFS ARC memory pressure to FreeBSD [1] How do you think of it, Karl? [1] https://reviews.freebsd.org/D7538 945036 266 karl 2017-07-30 15:47:00 +0000 (In reply to Tomoaki AOKI from comment #265) At first blush this looks quite interesting in that included is a means of determining allocated-but-unused UMA memory, which can (at minimum) improve decision-making on whether you *really* are low on RAM or not. I'm not actively working this at the present time but will stick a reminder up to look at it in more depth against 11.1 once I go down that road. Thanks! 953499 267 karl 2017-09-26 19:52:32 +0000 11.1 continues to inappropriately pare back ARC when it should not, forcing processes to swap inappropriately as well. I am testing an updated patch; the 11.0 patch does not cleanly apply, even with fuzz due to some internal changes in arc.c. I should have a new rev for 11.1-STABLE soon; it compiles at this point but I wish to run it for a week or so before publishing it so that it has at least a "one guy, one box, hit hard" soak test. 953915 268 186818 karl 2017-09-30 17:33:02 +0000 Created attachment 186818 Patch against r324056 (11.1-STABLE) w/Phabricator D7538 improvements Incorporate D7538 UMA cleanup improvements. By themselves there remains a problem with extremely large inact page counts pressuring the ARC and inappropriate eviction of RSS to page to leave ARC in place. The changes to D7538 implement the same heuristic as previous iterations, specifically: 1. Always favor RSS in RAM over ARC, since to evict RSS you must take one (guaranteed) I/O (and perhaps two if it is recalled) whereas holding ARC in RAM is done on the *speculation* you will save a future I/O. Thus RSS should always "win" over ARC if there is contention. To implement this begin paring back ARC somewhat before wakeup_pager is reached in free RAM. 2. Wake up the pagedaemon when we are materially below free_target so scrubbing of inact pages occurs when mild memory pressure exists. This prevents the ARC from being pared back when the consumer of large amounts of ram is inact pages which could otherwise be demoted. 953932 269 junchoon 2017-10-01 00:01:00 +0000 (In reply to karl from comment #268) Thanks for your work! Confirmed *applicable with some offsets on VM area (cleanly applicable to arc.c), *buildable /installable, *and boots fine on head r324080 amd64. But not yet stress-tested. 954083 270 junchoon 2017-10-02 12:02:39 +0000 (In reply to karl from comment #268) Noticed non-activated #IFDEFs for REAP_ARC. Should I activate it (e.g. via -DREAP_ARC on make command line) for some special cases? Or #define REAP_ARC is needed within the patch like WAKE_PAGER case? 954090 271 karl 2017-10-02 13:13:50 +0000 (In reply to Tomoaki AOKI from comment #270) No; that portion of the original code was there to handle what the "D" patch does now, and it does so in a more-elegant fashion. I will eventually remove that section of code entirely. 954093 272 junchoon 2017-10-02 13:57:46 +0000 (In reply to karl from comment #271) Understood. Thanks! Currently trying with regular load basis (on stable/11). This means that unless hit by massive updates or huge single port update, the loads would be relatively low. :-( Anyway, I'll report back if I found something strange. (e.g., swap occurs on cases known to NOT swaps with D7538 or your previous patch.) 960040 273 junchoon 2017-11-19 06:30:30 +0000 Just a heads-up for now. r325851 on head (MFC after: 3 weeks) broke this, including plain D7538 patch. [1] *Removes "needfree" variable. Current test status: Observing strange swaps. Swaps while rebuilding www/firefox, which didn't cause swaps with pure D7538 or previous patch here. What is strange is that sometimes doesn't swap within lookalike workloads. I'm looking for threshould of sysctl values to stop swapping, but not reliably succeeded for now. :-( [1] https://lists.freebsd.org/pipermail/svn-src-head/2017-November/106220.html 963907 274 tablosazi.farahan 2017-12-17 07:12:00 +0000 http://00014.ir http://1-flymusic.ir http://8y8.ir http://abanshargh.ir http://akstoaks.ir http://alibaba-fans.ir http://alvand-ads.ir http://amingames.ir http://amlake-pasargad.ir http://androidsystem.ir http://arax24.ir http://arax724.ir http://armanhardware.ir http://arsisgame.ir http://asanban.ir http://asanbaran.ir http://asgas.ir http://ashanews.ir http://asl-ic.ir http://astakala.ir http://atromarket.ir http://azarpajang.ir http://bahartent.ir http://bartarresins.ir http://bazigaranesahne.ir http://bermudasystem.ir http://buyclockfantasy.ir http://cs8.ir http://d77.ir http://dresskade.ir http://drhesabisch.ir http://editexpert.ir http://eemenshop.ir http://ehsa30.ir http://elameharighearjmand.ir http://e-larestan.ir http://elsku.ir http://emadcenter.ir http://eta90.ir http://far30sms.ir http://fixpost.ir http://fsbigroup.ir http://gemgem.ir http://glutenfree.ir http://group-software.ir http://harim-pak.ir http://hdserial.ir http://healthplanner.ir http://homana-nikooei.ir http://honardorcheh.ir http://honarshiraz.ir http://hsplaser.ir http://insat.ir http://iranitb.ir http://iranvmag.ir http://irboiler.ir http://isuntrade.ir http://ithandmade.ir http://jahantest1.ir http://karevanhayeqadir.ir http://kashmarsalam.ir http://kconf.ir http://kore2iran.ir http://kosar-kala.ir http://mahdidevotees.ir http://marjaehamayesh.ir http://mgolden.ir http://mhosein.ir http://mohsenmirzazadeh.ir http://myalibabamusic.ir http://nama94.ir http://nettrick.ir http://niaze-rooz.ir http://noaradecor.ir http://nod32-pass.ir http://novindpfile.ir http://n-vasegh.ir http://parlpd.ir http://photoselfi.ir http://pooyawood.ir http://roofbam.ir http://saadatedu.ir http://saba-gostar.ir http://sadafwood.ir http://sadcover.ir http://s-amini.ir http://sarebanekavir.ir http://sazmansokhan.ir http://shafaghgostaran.ir http://shandizasansor.ir http://sh-iranshahr.ir http://sms7000.ir http://sogandmusic.ir http://steelfood.ir http://sticker1.ir http://technoguard.ir http://tegolestan.ir http://telegramup.ir http://torbat24.ir http://trustech.ir http://turkmenili.ir http://vray4max.ir http://winsoftware.ir http://www.3hf.ir http://www.4drupal.ir http://www.arazinet.ir http://www.arianagame.ir http://www.clickbartar.ir http://www.maxstoreco.ir http://www.daryabchat.ir http://www.eset-ir.ir http://www.marketstudies.ir http://www.raadmehr.ir http://www.rcmb.ir http://www.shahinmag.ir http://www.starfam.ir http://www.steel-industrial.ir http://www.suqr.ir http://www.tajervenizi.ir http://www.zarrindesign.ir http://yahoo-shop.ir ------------------------------------------------------------ http://appsray.ir http://rayit.ir http://webonyan.ir http://raypress.ir http://webbonyan.ir http://gameray.ir http://egameweb.ir http://webiweb.ir http://raystore.ir http://raysecurity.ir http://webegame.ir http://rayananews.ir http://webitt.ir http://alsafir.ir http://www.fun30t.ir http://www.adrh.ir http://2funsara.ir http://www.saesamane.ir http://themefars.ir http://irhip.ir http://www.sharj25.ir http://maraghehee.ir http://mathpub.ir http://seminar-learning.ir http://shahrekord-ads.ir http://mobchat.ir http://www.nativeiran.ir http://www.water-iut.ir http://www.irancnco.ir http://itlovers.ir http://www.shamimemahneshan.ir http://kootool.ir http://www.waghe-e.ir http://www.ncema.ir http://hamayeshmehr.ir http://baranclip.ir http://darab-ads.ir http://nooreravand.ir http://www.bonarazadegantaziyeh.ir http://www.sorkhaabi.ir http://janjalynews.ir http://fastcamp.ir http://www.sekeh337.ir http://www.iqc13.ir http://www.aliarm.ir http://www.malakbanoo.ir http://www.pt30.ir http://www.rianco.ir http://www.tex-one.ir http://www.facialmask.ir http://takestan-ads.ir http://www.shervinpardaz.ir http://www.weecharge.ir http://hamedan-music.ir http://www.2pmusic.ir http://www.memarydownload.ir http://www.sayeh66.ir http://www.tobuy.ir http://www.isfahancycling.ir http://tehran-investment.ir http://neginemahvelat.ir http://www.iran-night.ir http://soft2015.ir http://2roos.ir http://elschool.ir http://www.chahkor.ir http://naubahar.ir http://majidshakeri.ir http://www.smsjadid.ir http://www.mountainguides.ir http://nice-sms.ir http://aeoiconf.ir http://www.mathrde.ir http://bizir.ir http://nafis-co.ir http://rbt-pishvaz.ir http://hashtagco.ir http://www.mdcorp.ir http://mubonit.ir http://storeha.ir http://www.faraghat-kh.ir http://www.ilamph.ir http://fatemyeh-ravand.ir http://www.alifr.ir http://oxindata.ir http://biofa.ir http://sinababaei.ir http://zarinfa.ir http://www.hyppercom.ir http://www.dlall.ir http://www.arse3.ir http://www.polkanhaml.ir http://sportingshop.ir http://abrebaran.ir http://ava-code.ir http://modarooz.ir http://www.cgmaster.ir http://www.rafeeds.ir http://isf-26.ir http://mesbahrc.ir http://garch98.ir http://www.magtour.ir http://rasalinux.ir http://photo4u.ir http://parscamp.ir http://www.bazare-amlak.ir http://afathi.ir http://zyaoddin.ir http://www.chbchess.ir http://www.miladlabs.ir http://nimaadvertise.ir http://sms-inbox.ir http://jo0k.ir http://rankalexa1.ir http://trmaw.ir http://ig114.ir http://foxtarh.ir http://dailex.ir http://graphicworld.ir http://www.jccac.ir http://aazam9.ir http://farhangishu.ir http://rohabmusic.ir http://petroleum-eng.ir http://www.redcircle.ir http://www.webhostsearch.ir http://www.besharate-no.ir http://sadebegir.ir http://sadrdanesh.ir http://joks.ir http://98patoghi.ir http://iranturkmenleri.ir http://bamboblog.ir http://amarm.ir http://www.drmotamednejad.ir http://www.adskg.ir http://akschin.ir http://logosaz3d.ir http://ifmee.ir http://khaf-tavan.ir http://www.asalbeheshti.ir http://www.tannazghorbani.ir http://aroosbahar.ir http://hismusic.ir http://abdarya.ir http://hirubsungharchak.ir http://neskaenergy.ir http://alborzbano.ir http://www.hamyari-lr.ir http://10cec.ir http://www.mpcms.ir http://parmisseed.ir http://itraveltour.ir http://maghalateisi.ir http://payamak21.ir http://farsipaper.ir http://www.f3000.ir http://www.aminmoshaver.ir http://btc-info.ir http://ayoubsys.ir http://dr-seo.ir http://salehmedia.ir http://resaneh1.ir http://3rdnci-asna-ipp.ir http://alishateri.ir http://gis98.ir http://www.darolfeiz.ir http://chaijan.ir http://zarasang.ir http://imenhazrati.ir http://aboutmore.ir http://smscontest.ir http://sazefelezipaydar.ir http://www.iltayco.ir http://aradcover.ir http://www.12313.ir http://www.featdesign.ir http://www.golestannjf.ir http://www.istgahniyaz.ir http://ctmusic.ir http://www.farsi-download.ir http://thermowoods.ir http://www.nshgm1.ir http://sepehrportal.ir http://globalchat.ir http://downloadzzz.ir http://majid-phone1.ir http://my-channels.ir http://firoozehcarpet.ir http://footballlist.ir http://sepidarandesign.ir http://shc1.ir http://aabrothers.ir http://skyhope.ir http://www.archcontest.ir http://irmarket24.ir http://persian-tourism.ir http://mehranplastic.ir http://vozaramobl.ir http://golbargdairy.ir http://www.altinlift.ir http://drmoodi.ir http://nexclip.ir http://ghasemy50.ir http://www.avizhehsaz.ir http://mavvaj.ir http://overs.ir http://www.pay4sell.ir http://21dl.ir http://www.tasisatpardis.ir http://ostovatours.ir http://downloadpluse.ir http://buxnet.ir http://arad-volleyball.ir http://zanjanli.ir http://cc30shop.ir http://sms-contest.ir http://www.medodarman.ir http://hafezdriving.ir http://talarhashtbehesht.ir http://monomarket.ir http://ptpportal.ir http://nickelodeon.ir http://dlsoftwares.ir http://english4all.ir http://hafez-news.ir http://gamecheats.ir http://payacpc.ir http://www.pazhohe.ir http://qomikala.ir http://hompa.ir http://nasir-wood.ir http://entezarsoft.ir http://www.pnu-soal.ir http://kiofood.ir http://hotelconference.ir http://frotel47.ir http://ks-co.ir http://es-k.ir http://3venshop.ir http://vectoria.ir http://farskids1.ir http://persian-gta.ir http://mamanha3.ir http://refquiz.ir http://www.agcom.ir http://tandistak.ir http://kimiafam.ir http://farzandan3.ir http://daneshgu.ir http://aeua.ir http://www.m3dia.ir http://www.game123.ir http://www.nirvanaweb.ir http://www.kfmisagh.ir http://zabax.ir http://www.sobhangen.ir http://www.yyar.ir http://www.hsqom.ir http://www.parandstudio.ir http://www.cpu64.ir http://ps-music.ir http://www.tfarahan.ir http://www.zarinfair.ir http://www.mvcportal.ir http://healthcarecenter.ir http://careonline.ir http://turkinc.ir http://healthcareonline.ir http://khoyweb.ir http://raycomarket.ir http://raycosoftware.ir http://raycostore.ir http://raycotec.ir http://rayct.ir http://raysoft.ir http://raytc.ir http://webkhoy.ir http://melkaras.ir http://market-aras.ir http://i-aras.ir http://e-aras.ir http://earas.ir http://clinictabriz.ir http://aras-market.ir http://tejartaras.ir http://tebtabriz.ir http://tebsonatitabriz.ir http://tabrizdoctor.ir http://shop-aras.ir http://khoytokhmeh.ir http://hypertabriz.ir http://hostturk.ir http://goldtabriz.ir http://faratabriz.ir http://calltabriz.ir http://bazartokhmeh.ir http://turkhost.ir http://tokhmeshop.ir http://tokhmehshop.ir http://tokhmehcenter.ir http://tokhmecenter.ir http://tabrizyab.ir http://tabriztv.ir http://tabrizno.ir http://tabrizgame.ir http://tabrizengine.ir http://tabrizcall.ir http://santtabriz.ir http://hotel-aras.ir http://onlinik.ir/ http://cloudonlinenic.ir/ http://madraseonline.ir/ http://madrasehonline.ir/ http://madaresonline.ir/ http://khoybazari.ir/ http://bazarionline.ir/ http://urmiabazari.ir/ http://salmasbazari.ir/ http://onlinnic.ir/ http://nomrehonline.ir/ http://nomaratonline.ir/ http://webmastertabrizurmiabazari.ir/ http://webmastertabriz.ir/ http://tabrizcad.ir/ http://sanattabriz.ir/ http://khoyhyper.ir/ http://khoyhony.ir/ http://khoyfarsh.ir/ http://khoyasal.ir/ http://hyperaras.ir/ http://honykhoy.ir/ http://farshkhoy.ir/ http://datacentertabriz.ir/ http://asalkhoy.ir/ http://arasshopcenter.ir/ http://7namehkhoy.ir/ http://turkshopcenter.ir/ http://tabriztools.ir/ http://tabrizstudio.ir/ http://tabrizscan.ir/ http://tabrizpizza.ir/ http://tabrizpark.ir/ http://tabrizmodir.ir/ http://tabrizmarktabrizmaster.ir/ http://tabrizmark.ir/ http://tabrizkadeh.ir/ http://tabrizkade.ir/ http://tabrizhelp.ir/ http://tabrizgram.ir/ http://tabrizwork.ir/ http://tabrizmoble.ir/ http://tabrizhouse.ir/ http://tabrizcar.ir/ ------------------------------------ http://www.amar365.ir http://09123498298.ir http://pamar.ir http://arazproje.ir http://signsaras.ir http://signsaraz.ir http://signsfarahan.ir http://suleforosh.ir http://tabloosazi.ir http://zaminforosh.ir http://9125879258.ir http://9375883058.ir http://www.lbfarahan.ir http://www.ghfarahan.ir http://pix-land.blogfa.com http://projeamar.blog.ir http://projectstatis.blogfa.com http://projectstatis.rozblog.com http://projectstatistics.blog.ir http://projectstatistics.niloblog.com http://projectstats.avablog.ir http://projectstats.blog.ir http://projectstats.javanblog.ir http://projectstats.samenblog.com http://projectstats1.blogfa.com http://projectstatus.avablog.ir http://prozhe-amar.blogfa.com http://spam.blogfa.com http://stats09375883058.blogfa.com http://projeamari.blogfa.com http://projectanalysis.mihanblog.com http://statisticsproject.blogfa.com http://tahghighstan.blogfa.com http://www.amar101.blogfa.com http://saheldarya.7blog.ir http://pezeshkyar.arisfa.com http://Shabebarfi.armanblog.ir http://varzeshsara.avablog.ir http://Azadweb.azadblog.com http://Batoo.b88.ir http://dostan.bestblog.ir http://Toristi.bigsite.ir http://Tarane18.blog.ir http://Hambaazi.blogfa.com http://estekhdami.blogia.ir http://behtarinha.blogiran.net http://Musicnaab.blognovin.com http://baharnarenj.blogparsi.com http://Molodi.blogpart.ir http://Bestgirl.blograz.ir http://razesalamati1.blogsky.com http://Alghameh.blogtarin.com http://deklameh.blogtez.com http://taranoom18.blogveb.com http://dabirestani.deyblog.ir http://amozeshyar.eklablog.com http://donyayenet.epage.ir http://mamnoo.famblog.ir http://tabasom.farazblog.com http://daneshjoei.fardblog.com http://Nemonehsoal.farsiblog.com http://tabestoon.geblog.ir http://maghaleh.iran.sc http://funkadeh.iranblag.com http://fotoax.jahanblog.net http://shabgard.jasaz.com http://jazadkadeh.javanblog.ir http://khabarjadid.limooblog.com http://tanzkadeh.loxblog.com http://tahghigh18.mihanblog.com http://niazmandiha.mojblog.ir http://niazsara.monoblog.ir http://divari.nedablog.ir http://Darham.niazblog.ir http://dabestan.niloblog.com http://salamati.novinblog.net http://dehati.parsablog.com http://Baharnews.parsiblog.com http://tanhatarin.parsunit.com http://doghalb.persianblog.ir http://yadgari.ratablog.com http://baharestan.roomfa.com http://modkadeh.royablog.ir http://sargarmi724.rozblog.com http://webmasteri.samenblog.com http://mosaferati.shblog.ir http://gardeshgari.sitearia.ir http://Khandani.smu.ir http://ahangjadid.takblog.net http://filmjadid.tarlog.com http://mashinbaz.tibablog.ir http://lebasmajlesi.tinablog.ir http://backlink724.titrblog.ir http://bazigaran.toonblog.ir http://pishwaz.twoblog.ir http://madahi.wblog.xyz http://hotelyar.yektablog.net http://digibacklink.ir/ http://dgbacklink.ir/ http://royalbacklink.ir/ http://highbacklink.ir/ http://1zekr.com/forums/member.php?u=5634 http://1zekr.yaalee.com/forums/member.php?u=5634 http://220volt.ir/forum/threads/637 http://2l-f.com/vb/member.php?u=935 http://2ndvarp.net/member.php?716-tablooaraz http://3dpe.ir/forum/threads/%D8%B7%D8%B1%D8%A7%D8%AD%DB%8C-%D8%B3%D8%A7%DB%8C%D8%AA-%D8%B5%D8%B1%D8%A7%D9%81%DB%8C.75/ http://3ss3.com/member.php?u=21209 http://4glte.vn/member.php?u=13460 http://4r.mu-viet.vn/showthread.php?1323-H%C6%B0%E1%BB%9Bng-d%E1%BA%ABn-ch%E1%BB%A9c-n%C4%83ng-m%E1%BB%9Bi-Reset-B%C3%B9-v%C3%A0-Reset-H%E1%BB%99&p=14999#post14999 http://4um.overclocking.cz/member.php?u=34728 http://aces.ir/blogs/tablooaraz/699-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9-%D8%AD%D8%B1%D9%81%D9%87-%D8%A7%DB%8C.html http://aces.ir/members/tablooaraz.html http://adminzone.ir/topic/161-%D8%B3%DB%8C%D8%B3%D8%AA%D9%85-%D9%85%D8%AF%DB%8C%D8%B1%DB%8C%D8%AA-%D9%85%D8%AD%D8%AA%D9%88%D8%A7-cms-%DA%86%DB%8C%D8%B3%D8%AA/ http://afroforum.ru/member.php?u=1790 http://alhoush.com/forums/member.php?121997-tablooaraz http://alivahedidiz.com/forum/showthread.php?tid=3108 http://alphacs.ro/member.php?34156-tablooaraz http://alqsid.com/vb/member.php?u=397 http://animeleague.net/forum/member.php?104953-tablooaraz http://anjoman.parsfootball.com/member.php?u=34586 http://anjoman.roochi.ir/showthread.php?tid=2337 http://arabiforall.com/Forum/Post/66/ http://arshadeomran.ir/forum/thread1030-97.html http://artificial.ir/intelligence/member.php?u=134589 http://asemaniha.net/forum/member.php/549-tablooaraz http://asl8.ir/social/thread-101.html http://asrenevisandegi.com/index.php?/topic/595-%D8%B7%D8%B1%D8%A7%D8%AD%DB%8C-%D8%B3%D8%A7%DB%8C%D8%AA-%D8%B4%DB%8C%D8%B1%D8%A7%D8%B2/ http://aswaqbayte.com/member.php?u=2797 http://ayask.com/forum/viewtopic.php?f=21&t=993 http://a-zgsm.com/mobile/member.php?4695-tablooaraz http://azpnu.ir/User-tablooaraz--28367 http://baharsite.com/forum/viewtopic.php?f=150&t=735&p=60813 http://baharsite.com/forum/viewtopic.php?f=150&t=735&p=60813#p60813 http://baras.ir/forum/thread-637-post-32099.html http://bda.lovebongda.com/member.php?u=15310 http://bdc-forum.it/member.php?u=109212 http://behdari.com/Thread-%D8%AE%D9%88%D8%A7%D8%B5-%D8%AE%D8%A7%D8%B1-%D9%85%D8%B1%D9%8A%D9%85-%D8%AF%D9%88%D8%B3%D8%AA-%D8%A8%D8%A7-%D9%88%D9%81%D8%A7%D9%8A-%D9%83%D8%A8%D8%AF http://beltronicsradarforum.com/forums/member.php?u=2591 http://beporsbedoon.com/showthread.php?7717-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9&p=13967#post13967 http://beyamooz.com/forum/members/1026-tablooaraz http://bia2skin.ir/forum/member.php?u=4963 http://biketrials.ru/live/member.php?u=49421 http://blogandforum.fairfaxcryobank.com/forum/member.php?51418-tablooaraz http://blogandforum.fairfaxcryobank.com/forum/member.php?51418-tablooaraz&tab=visitor_messaging&page=2#visitor_messaging http://bodogame.com/forum/members/1422.html http://bodyclass.ir/Thread-%D8%AA%D9%81%D8%A7%D9%88%D8%AA-%D8%AA%D8%A8%D9%84%DB%8C%D8%BA%D8%A7%D8%AA-%D8%B7%D8%B1%D8%A7%D8%AD%DB%8C-%D8%B3%D8%A7%DB%8C%D8%AA http://bpums.ac.ir/forums/yaf_postsm2204_khsht-mw-dr-khnm-h.aspx http://bulletin.thewho.com/member.php?6535-tablooaraz http://bulletin.thewho.com/member.php?6535-tablooaraz&tab=visitor_messaging&page=2#visitor_messaging http://bulug.ir/forum/User-roozfreight http://cafemohinh.vn/member.php?u=2065 http://camcom.cc/vb/member.php?u=1109 http://carina-club.ru/member.php?u=30625 http://cfps.pl/forum/member.php?u=13385350 http://cgworkshop.org/forum/member.php?41864-tablooaraz http://clancommunity.ru/member.php?tab=visitor_messaging&u=13745&page=2#visitor_messaging http://clancommunity.ru/member.php?u=13745 http://clan-dfm.org/forums/member.php?u=2318 http://cmmnty.mthmtcs.ir/index.php?threads/%D8%B3%D9%88%D8%A7%D9%84%D8%A7%D8%AA-%D8%A2%D8%B2%D9%85%D9%88%D9%86-%DA%A9%D8%A7%D8%B1%D8%B4%D9%86%D8%A7%D8%B3%DB%8C-%D8%A7%D8%B1%D8%B4%D8%AF-94.78/ http://code-igniter.ir/showthread.php?tid=41 http://codfans.ir/member.php?19398-tablooaraz http://community.arab.sh/member.php?u=5964 http://community.kingofflips.com/member.php?120625-tablooaraz http://community.mybbiran.com/thread-20268-post-145255.html http://csko.cz/forum/member.php?133346-tablooaraz http://cuddetalk.com/member.php?6901-tablooaraz http://d4mb.ir/Forum/Post/160/Page/1 http://dalghak.net/forum/Thread-%D8%A7%D8%AC%D8%A7%D8%B1%D9%87-%D8%AE%D9%88%D8%AF%D8%B1%D9%88-%D8%A2%D9%85%D8%B1%DB%8C%DA%A9%D8%A7%DB%8C%DB%8C http://dangtocvietnam.com/diendan/member.php?u=882 http://dark-age.com/forum/member.php?9618-tablooaraz http://darknet.su/member.php?37058-tablooaraz http://dashtiha.com/Thread-%D8%AC%D8%A7%D8%B0%D8%A8%D9%87-%D9%87%D8%A7%DB%8C-%DA%AF%D8%B1%D8%AF%D8%B4%DA%AF%D8%B1%DB%8C-%DA%A9%D8%A7%D9%86%D8%A7%D8%AF%D8%A7 http://dd.muvn2.net/member.php?9875-tablooaraz http://diendan.cnttcd8.edu.vn/member.php?18260-tablooaraz http://diendan.dienchan.com/member.php?22741-tablooaraz http://diendan.huyenthoaimu.net/member.php?1782-tablooaraz http://diendan.kiemthebavuong.com/member.php?2574-tablooaraz http://diendan.muhaokiet.com/member.php?11798-tablooaraz http://diendan.muhuyenthoai.com/member.php?12629-tablooaraz http://diendan.mu-korea.net/member.php?7539-tablooaraz http://diendan.muphilong.com/member.php?9306-tablooaraz http://diendan.muphuchung.com/member.php?9398-tablooaraz http://diendan.musaigon.vn/member.php?114384-tablooaraz http://diendan.muthaiduong.vn/member.php?5411-tablooaraz http://diendan.muthienviet.com/member.php?11804-tablooaraz http://diendan.mutuyetdinh.com/member.php?8693-tablooaraz http://diendan.muviet.com/member.php?43673-tablooaraz http://diendan.muvietss6.vn/member.php?3707-tablooaraz http://dmctalk.org/member.php?88260-tablooaraz http://dtphorum.com/pr4/member.php?59406-tablooaraz http://egyhunt.net/member.php?u=19709 http://elderscrolls-online.tiscali.cz/forums/member.php?2631-tablooaraz http://elmas.ir/forum/member.php?3301-tablooaraz http://elmas.ir/forum/showthread.php?322-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9 http://en.blitzkrieg.com/forum/member.php?u=71284 http://enad199.com/vb/member.php?u=9076 http://eye4you.ir/forum/member.php?3422-tablooaraz http://f.havajanah.ir/showthread.php?tid=248 http://fanzine.ir/memberlist.php?mode=viewprofile&u=2391 http://farspatogh.ir/entries/21727/ http://fcbavaria.ir/forum/members/tablooaraz/ http://fclan.ru/4room/member.php?u=5224 http://ffnet.net/forum/member.php?u=9474 http://filforex.com/vb/member.php?u=3719 http://forsakenforum.de/member.php?41270-tablooaraz http://forum.abfa-khj.ir/showthread.php?2-hi-to-all-peolle http://forum.abfa-khj.ir/showthread.php?63-%D8%AC%D8%B4%D9%86-%D9%85%D8%A7%D9%87-%DA%A9%D8%A7%D9%85%D9%84 http://forum.acgih.ir/members/tablooaraz.html http://forum.activerayan.ir/member.php?45-tablooaraz http://forum.allgsmunlock.com/member.php?270159-tablooaraz http://forum.androidsos.ir/showthread.php?tid=130706 http://forum.aratta.ir/member.php?228-tablooaraz http://forum.aratta.ir/member.php?228-tablooaraz http://forum.arduino.ir/4/15/1777.html http://forum.arvandplak.ir/member.php?u=2233 http://forum.arvandplak.ir/showthread.php?t=630 http://forum.atomfish.ru/member.php?u=51439 http://forum.bafghsalam.ir/showthread.php?tid=2777 http://forum.banianbehboodi.ir/showthread.php?tid=7417 http://forum.barato.ir/Thread-%D8%B1%D8%A7-%D9%87%D8%A7%DB%8C-%D8%A7%D9%81%D8%B2%D8%A7%DB%8C%D8%B4-%D8%A8%D8%A7%D8%B2%D8%AF%DB%8C%D8%AF-%D8%B3%D8%A7%DB%8C%D8%AA http://forum.bargtools.ir/showthread.php?tid=5716 http://forum.barname.org/showthread.php?t=1840 http://forum.bazaarbargh.ir/entry.php?10-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9-%D8%AD%D8%B1%D9%81%D9%87-%D8%A7%DB%8C-%D9%88-%D8%A7%D8%B1%D8%B2%D8%A7%D9%86 http://forum.boi-velos.com/member.php?u=3354 http://forum.cafedexign.com/members/47854.html http://forum.cakephp.ir/thread-1578-post-8812.html http://forum.cinemacenter.ir/member33875.html http://forum.codecorona.com/showthread.php?tid=7152 http://forum.cytco.net/member.php?u=118 http://forum.dejkoob.ir/member.php?u=3211 http://forum.diangucmu.com/member.php?4518-tablooaraz http://forum.dotabaz.com/member6948.html http://forum.download.ir/member/900-tablooaraz http://forum.download.ir/member/900-tablooaraz http://forum.drasgharian.ir/entry.php?12-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9-5 http://forum.dubbedclub.com/member.php?u=1775 http://forum.dubbedclub.com/showthread.php?t=1893 http://forum.duragarages.com/member.php?150468-tablooaraz http://forum.eastmans.com/member.php/13669-tablooaraz http://forum.edcoan.ir/entry.php?21-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9-5 http://forum.entitygaming.com/member.php?10852-tablooaraz http://forum.eslamteb.com/Post/1373/ http://forum.exceliran.com/member.php/48002-tablooaraz http://forum.faosclass.com/Thread-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9 http://forum.farsdownload.net/member.php?84-tablooaraz http://forum.firooz.com/viewtopic.php?f=75&t=6999 http://forum.freedownload.ir/thread-400598.html http://forum.gamgos.net/member/86804-tablooaraz http://forum.gharchsanat.ir/showthread.php?tid=126 http://forum.giamsat.org/member.php?27386-tablooaraz http://forum.goaudio.su/member.php?77201-tablooaraz http://forum.graphiran.com/members/tablooaraz.html http://forum.gsm-developers.com/profile/23630-tablooaraz/ http://forum.gtr-masters.hu/member.php?7690-tablooaraz http://forum.hadafdownload.com/member.php?2162-tablooaraz http://forum.hadafdownload.com/showthread.php?2648-%D8%B4%D8%B1%D8%A7%DB%8C%D8%B7-%D9%88-%D9%85%D9%88%D9%84%D9%81%D9%87-%D9%87%D8%A7%DB%8C-%D9%87%D8%A7%D8%B3%D8%AA-%D8%AE%D9%88%D8%A8-%D8%AF%D8%B1-%D8%B7%D8%B1%D8%A7%D8%AD%DB%8C-%D8%B3%D8%A7%DB%8C%D8%AA http://forum.himym.cz/viewtopic.php?f=12&t=32067 http://forum.hl.ua/member.php?u=57448 http://forum.hnkvz.hr/member.php?u=2362 http://forum.hogwartz.ir/member.php?2330-tablooaraz http://forum.hpaba.com/member.php?481-tablooaraz http://forum.illpumpyouup.com/member.php?u=12690 http://forum.imanvfx.com/thread3285.html http://forum.irani-dl.com/thread453.html http://forum.iran-mavad.com/member.php?u=9361 http://forum.ir-click.com/index.php?topic=788.0 http://forum.jdmstyletuning.com/member.php?42962-tablooaraz http://forum.kafesahel.com/member/21-tablooaraz http://forum.kalimdor.ir/member.php?628-tablooaraz http://forum.kalout.ir/blogs/tablooaraz/%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9-20/ http://forum.kara365.ir/entry.php?2651-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9-%D8%A7%D8%B1%D8%B2%D8%A7%D9%86-%D9%88-%D8%AD%D8%B1%D9%81%D9%87-%D8%A7%DB%8C http://forum.kavoshteam.com/members/tablooaraz/25-1.html http://forum.kgb-hosting.ro/member.php?408-tablooaraz http://forum.korepix.ir/Post/969 http://forum.leagueoflegunds.ir/member.php?995-tablooaraz http://forum.legionisci.com/member.php?u=152091 http://forum.legion-noire.com/member.php/734-tablooaraz http://forum.mehad.ir/showthread.php?t=106 http://forum.mimsoft.ir/member.php?714-tablooaraz http://forum.misawa.de/member.php/2305-tablooaraz http://forum.mkcenter.ir/member.php?u=21693 http://forum.mobile4persian.net/member113358.html http://forum.monji12.com/threads/25198/ http://forum.motarjemonline.com/member/9829-tablooaraz http://forum.motarjemonline.com/member/9829-tablooaraz http://forum.mspsoft.com/members/tablooaraz.html http://forum.mu4viet.com/member.php?u=5070 http://forum.muanhhung.com/member.php?8003-tablooaraz http://forum.muanviet.com/member.php?5578-tablooaraz http://forum.mubachkim.com/member.php?8407-tablooaraz http://forum.mubachu.com/member.php?7995-tablooaraz http://forum.mubacviet.com/member.php?6215-tablooaraz http://forum.mubalong.net/member.php?6617-tablooaraz http://forum.mubaochau.com/member.php?7614-tablooaraz http://forum.mubaoviet.net/member.php?u=4138 http://forum.mubavuong.net/member.php?u=3854 http://forum.mubomtan.com/member.php?u=3345 http://forum.mubz.bg/member.php?u=2738 http://forum.muchaulong.com/member.php?10995-tablooaraz http://forum.muchuate.com/member.php?9118-tablooaraz http://forum.mudainam.net/member.php?5436-tablooaraz http://forum.mudaiviet.com/member.php?7960-tablooaraz http://forum.mudangcap.vn/member.php?3107-tablooaraz http://forum.mudenhat.com/member.php?8343-tablooaraz http://forum.mudinhcao.net/member.php?u=3231 http://forum.mudinhmenh.com/member.php?5550-tablooaraz http://forum.mufptvn.com/member.php?u=3351 http://forum.mugiangho.com/member.php?8438-tablooaraz http://forum.muhacvuong.com/member.php?5447-tablooaraz http://forum.muhaiphong.vn/member.php?8577-tablooaraz http://forum.muhanoiss6.com/member.php?u=3371 http://forum.muhiepkhach.com/member.php?8125-tablooaraz http://forum.muhoangdao.com/member.php?6354-tablooaraz http://forum.muhoanglong.net/member.php?u=4061 http://forum.muhoanhao.com/member.php?9089-tablooaraz http://forum.muhoanmy.com/member.php?9326-tablooaraz http://forum.muhoisinh.com/member.php?7983-tablooaraz http://forum.muhoisinh.net/member.php?u=3426 http://forum.muhoisinh.net/member.php?u=3426 http://forum.muhoiuc.net/member.php?u=3239 http://forum.muhuyenthoaiss6.com/member.php?u=3814 http://forum.muhuyetlong.net/member.php?u=3642 http://forum.mukhaihoan.com/member.php?u=3896 http://forum.mukhatvong.net/member.php?u=4203 http://forum.mukinhdo.com/member.php?6255-tablooaraz http://forum.mulacviet.com/member.php?11620-tablooaraz http://forum.mulienviet.com/member.php?8555-tablooaraz http://forum.mulucdia.com/member.php?u=4689 http://forum.mumienbac.com/member.php?u=3918 http://forum.munamquoc.com/member.php?10188-tablooaraz http://forum.munuthan.com/member.php?10731-tablooaraz http://forum.munuvuong.com/member.php?10646-tablooaraz http://forum.muphucsinh.com/member.php?11601-tablooaraz http://forum.muquocte.com/member.php?u=3458 http://forum.muquyenluc.com/member.php?8428-tablooaraz http://forum.muquyvuong.com/member.php?8243-tablooaraz http://forum.musaigonss6.com/member.php?u=3618 http://forum.musieuviet.com/member.php?8566-tablooaraz http://forum.muss2.vn/member.php?45618-tablooaraz http://forum.muss7.com/member.php?u=4415 http://forum.muss8.net/member.php?u=3836 http://forum.mustatir.com/showthread.php?tid=43 http://forum.musv.net/member.php?8073-tablooaraz http://forum.mutaisinh.net/member.php?u=3333 http://forum.muthanhcong.com/member.php?8307-tablooaraz http://forum.muthanhdia.com/member.php?8263-tablooaraz http://forum.muthanvu.com/member.php?7803-tablooaraz http://forum.mutheky.com/member.php?8030-tablooaraz http://forum.muthienkim.vn/member.php?3839-tablooaraz http://forum.muthienmenh.net/member.php?u=3519 http://forum.muthienmenh.net/member.php?u=3519 http://forum.muthienquoc.com/member.php?5448-tablooaraz http://forum.muthientu.net/member.php?1488-tablooaraz http://forum.muthientu.vn/member.php?29992-tablooaraz http://forum.muthoidai.com/member.php?8377-tablooaraz http://forum.muthoigian.net/member.php?99-tablooaraz http://forum.mutienphong.com/member.php?5428-tablooaraz http://forum.mutoanquoc.com/member.php?u=3874 http://forum.mutranhba.net/member.php?u=3950 http://forum.mutranhba.net/member.php?u=3950 http://forum.mutranhba.net/member.php?u=3950 http://forum.mutruyenkyss6.com/member.php?u=3787 http://forum.muviet.net.vn/member.php?16315-tablooaraz http://forum.muvietnamss6.com/member.php?u=4280 http://forum.muvietss7.com/member.php?u=4415 http://forum.muvietvuong.com/member.php?8164-tablooaraz http://forum.muvinhcuu.com/member.php?6382-tablooaraz http://forum.muxungba.com/member.php?u=3369 http://forum.naghsh-negar.ir/showthread.php?7141-%D9%87%D8%AA%D9%84-%D9%BE%D8%A7%D8%B1%D9%85%DB%8C%D8%B3-%DA%A9%DB%8C%D8%B4 http://forum.najrobotics.com/showthread.php?tid=1496 http://forum.nis.singidunum.ac.rs/member.php?708-tablooaraz http://forum.oghyanos.ir/thread1032.html http://forum.p30download.com/member.php?332122-tablooaraz http://forum.p30talk.com/index.php?threads/%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9-5.627/ http://forum.p30world.com/member.php?u=1335477 http://forum.p313.ir/member.php?action=profile&uid=1574 http://forum.parsbtc.com/member.php?927-tablooaraz http://forum.parsiking.com/member.php?u=59156 http://forum.persianrc.com/showthread.php?p=122730 http://forum.persianseven.ir/t266943.html http://forum.pesholland.nl/member.php?1444-tablooaraz http://forum.pioneer-life.ir/member7451.html http://forum.pnu4u.com/showthread.php?tid=3625 http://forum.poemse.com/showthread.php?pid=2627 http://forum.pop-music.ir/threads/%D8%AF%D8%B4%D8%AA-%D8%AE%D8%B4%DA%A9%DB%8C%D8%AF%D9%88-%D8%B2%D9%85%DB%8C%D9%86-%D8%B3%D9%88%D8%AE%D8%AA-%D8%B4%D8%B9%D8%B1.11678/ http://forum.pstrophy.ir/member.php?684-tablooaraz http://forum.qeshmvoltage.com/showthread.php?tid=887 http://forum.razhanmobile.com/index.php?threads/%D8%A8%D9%87%DB%8C%D9%86%D9%87-%D8%B3%D8%A7%D8%B2%DB%8C-%D8%B3%D8%A7%DB%8C%D8%AA-%D8%B4%D8%B1%DA%A9%D8%AA-%D9%87%D8%A7%DB%8C-%D8%B5%D9%86%D8%B9%D8%AA%DB%8C.24820/ http://forum.razhanmobile.com/index.php?threads/بهینه-سازی-سایت-شرکت-های-صنعتی.24820 http://forum.roq.ir/u3700 http://forum.saabturboclub.com/member.php/103983-tablooaraz http://forum.safarnaame.ir/entry.php?1-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9 http://forum.scriptcamp.ir/Forum/Post/633 http://forum.semeng.ir/showthread.php?tid=27166 http://forum.shopkeeper.ir/showthread.php?t=106353 http://forum.skhorasaniec.ir/member.php?28090-tablooaraz http://forum.skhorasaniec.ir/member.php?28090-tablooaraz http://forum.smartbeen.com/showthread.php?tid=709 http://forum.springdl.ir/thread-31744-post-71071.html http://forum.talarearoos.com/thread-%D8%B7%D8%B1%D8%A7%D8%AD%DB%8C-%D8%A8%D8%B3%DB%8C%D8%A7%D8%B1-%D8%B2%DB%8C%D8%A8%D8%A7%DB%8C-%D9%81%D8%B6%D8%A7%DB%8C-%D8%AD%DB%8C%D8%A7%D8%B7--1348 http://forum.tambura.com.hr/member.php?u=8427 http://forum.tebpress.com/threads/19-%D8%A7%D8%B5%D9%84-%D9%85%D9%87%D9%85-%D8%B2%D9%86%D8%AF%DA%AF%DB%8C.719/ http://forum.techno-electro.com/%D9%85%D9%88%D8%B6%D9%88%D8%B9-%D8%A8%D9%87%D8%AA%D8%B1%DB%8C%D9%86-%D8%B1%D8%A7%D9%87-%D9%87%D8%A7%DB%8C-%D8%A8%D9%87%D8%A8%D9%88%D8%AF-%D8%B1%D8%AA%D8%A8%D9%87-%D8%B3%D8%A6%D9%88-%D8%AF%D8%B1-%DA%AF%D9%88%DA%AF%D9%84 http://forum.tehran-gaming.com/members/tablooaraz.html http://forum.tenisnews.com.br/member.php?u=31939 http://forum.tenpointcrossbows.com/member.php?16615-tablooaraz http://forum.tiguans.ru/member.php?u=49528 http://forum.troll98.ir/entry.php?10-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9-5 http://forum.ukuleleunderground.com/member.php?146273-tablooaraz http://forum.vegankind.ir/members/8524.html http://forum.vkontakte.dj/member.php?10018-tablooaraz http://forum.vmusic.ir/member.php?u=6597 http://forum.volleyworld.ir/Thread-%D8%A7%D9%87%D9%85%DB%8C%D8%AA-%D9%87%D8%AF%D8%A7%DB%8C%D8%A7%DB%8C-%D8%AA%D8%A8%D9%84%DB%8C%D8%BA%D8%A7%D8%AA%DB%8C-%D8%AF%D8%B1-%DA%A9%D8%B3%D8%A8-%D9%88 http://forum.walterfootball.com/member/209936-tablooaraz http://forum.wepage.ir/thread-28152-post-92811.html http://forum.wikigamers.ir/entry.php?9-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9 http://forum.windowsclub.net/member.php/25481-tablooaraz http://forumindo.com/member.php?66634-tablooaraz http://forums.arlongpark.net/member.php?u=81621 http://forums.bizna.ir/showthread.php?tid=4965 http://forums.bizna.ir/showthread.php?tid=632 http://forums.boursy.com/member.php?u=14711 http://forums.boursy.com/member.php?u=14711 http://forums.computershopper.com/member.php?u=45891 http://forums.directhosting.ca/member.php?23665-tablooaraz http://forums.episodeinteractive.com/member/82274-tablooaraz http://forums.forestbear.net/member.php?4633-tablooaraz http://forums.gingerscraps.net/member.php?21296-tablooaraz http://forums.mtbr.com/member.php?u=830836 http://forums.nodiatis.com/forums/member.php?u=59407 http://forums.nodoubt.com/member.php?35960-tablooaraz http://forums.p30day.com/member/60979-tablooaraz http://forums.p30day.com/member/60979-tablooaraz http://forums.parsjoom.ir/thread-20768-post-100351.html http://forums.pcpowerplay.com.au/member.php/133136-tablooaraz http://forums.persianinoz.com/members/tablooaraz.html http://forums.prosportsdaily.com/member.php?396679-tablooaraz http://forums.show-time.top/member.php?u=29230 http://forums.tehranpatogh1.ir/member.php?action=profile&uid=167 http://forums.tppc.info/member.php?u=30780 http://forums.warchest.com/member.php/111729-tablooaraz http://forumunik.com/member.php?4532-tablooaraz http://forzainterforums.com/member.php?9527-tablooaraz http://freetalk.takbb.ir/showthread.php?tid=3278 http://game.kuban.ru/forum/member.php?u=231 http://gentra-club.com.ua/member.php/527-tablooaraz http://gfrc.vn/forum/member.php?u=28804 http://ghanunejazb.ir/forum/showthread.php?tid=3368 http://glxforum.ir/blogs/tablooaraz/11-backlink.html http://glxforum.ir/entry.php?b=4 http://glxforum.ir/entry.php?b=5 http://glxforum.ir/entry.php?b=6 http://glxforum.ir/entry.php?b=6 http://goldendict.org/forum/viewtopic.php?f=4&t=23616 http://goldendict.org/forum/viewtopic.php?f=4&t=23616&start=10 http://golestane.net/showthread.php?t=88897 http://gomatlab.com/forum/User-tablooaraz http://groobyforum.com/member.php?26630-tablooaraz http://haftkhat.ir/forum/members/tablooaraz/ http://hangcu.vn/member.php?u=104400 http://hbportal.ir/showthread.php?tid=68 http://help.shoguto.com/member.php?2349-tablooaraz http://highboostforum.com/forum/member.php/19992-tablooaraz http://hotshotsgolf.com/blog.php?3436-tablooaraz http://iibimsolutions.ir/forum/member.php?u=295 http://ilammoallem.ir/forum/showthread.php?tid=71 http://ipcamsoft.com/support/member.php?97733-tablooaraz http://iranbookforum.com/thread-3249-post-12554.html http://iranclubs.org/forums/member.php?u=40182 http://iranclubs.org/forums/member.php?u=40182 http://irandelphi.ir/member.php?u=2151 http://iranwebadmin.com/threads/6-اشتباه-مهلک-که-هر-طراح-سایتی-ممکنه-مرتکب-بشه.598/ http://irserv.ir/showthread.php?tid=3992 http://justih.org/Binder-Bench/member.php?u=16891 http://ketnoi123.com/member.php?u=41250 http://khoisukinhdoanh.net/member.php?108912-tablooaraz http://kpnu-csc.ir/forum/members/tablooaraz/72-a.html http://krkan-muzika.org/forum/member.php?25547-tablooaraz http://ladytalk.ir/member.php?action=profile&uid=716 http://lalaei.ir/Forum/User-tablooaraz http://landcruisergroup.com/vb/member.php?u=1161 http://limbine.com/thread-5236.html http://limbine.com/thread-5797-post-15748.html http://mafiaia.ir/entry.php?693-%D8%AE%D8%B1%DB%8C%D8%AF-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9 http://mamisite.com/forum/t1017-3.html http://medsmart.ir/forum/member.php?u=375 http://moshaverfa.com/forum/threads/17096/ http://my-bb.ir/Thread-%D9%81%D8%B1%D9%88%D8%B4-%D8%B3%D8%A7%DB%8C%D8%AA-%D8%AF%D9%84%D9%82%DA%A9 http://nabzezendegi.ir/Thread-%D8%A8%D9%87%D8%AA%D8%B1%DB%8C%D9%86-%D8%AF%DB%8C%D8%AF%D9%86%DB%8C%E2%80%8C%D9%87%D8%A7%DB%8C-%D9%85%D8%A7%D9%84%D8%B2%DB%8C--51240 http://naghdefarsi.com/forum.html?view=topic&catid=38&id=95076 http://net2web.ir/blogs/u784-e170/ http://noplus.ir/showthread.php?t=437 http://otageabi.ir/showthread.php?t=776 http://palarnet.ir/forum/User-tablooaraz http://palarnet.ir/forum/User-tablooaraz#comments/1 http://pamm-trade.com/forum/member/37-tablooaraz http://pasargadtabac.com/forum/showthread.php?tid=3223 http://pccamp.ir/forums/blogs/tablooaraz/a-109/ http://persianmotor.net/showthread.php?t=16651 http://persianpet.org/forum/member54343.html http://persian-roleplay.ir/member.php?120-tablooaraz http://phudeviet.org/forum/member.php?28149-tablooaraz.html http://pilotairline.ir/forums/entry.php?b=3 http://pishroforum.ir/member.php?action=profile&uid=5227 http://progforum.ir/threads/سوالات-رایج-سئو-سایت.4978/ http://promakers.ir/member.php?action=profile&uid=20716 http://promakers.ir/member.php?action=profile&uid=20716#comments/1 http://psypooya.ir/showthread.php?tid=180 http://rahpouyan.ir/tablooaraz http://ravanbonyan.com/forum/member.php?u=9051 http://rayatolmahdi.com/entry.php?2-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9-%D8%AD%D8%B1%D9%81%D9%87-%D8%A7%DB%8C http://rebelconquer.net/member.php/3318-tablooaraz http://sadeghsalamy.com/member.php?249-tablooaraz http://sahelanime.com/Forum/entry.php?b=13 http://salamjavaneh.ir/thread-3923-post-205214.html http://sescoshop.com/forums/showthread.php?tid=21 http://sfk.ibk.se/forum/member.php?50081-tablooaraz http://skyforum.ir/showthread.php?tid=6 http://spfga.org/forum/member.php?2705-tablooaraz http://springwoodslasher.com/forum/member.php/4625-tablooaraz http://tadbiraneh.com/member.php?3108-tablooaraz http://technotop.ir/forum/members/tablooaraz.htm http://tonel.org/thread15828.html http://topostudio.ir/Thread-کاغذ-دیواری-سه-بعدی http://trade.takbb.ir/showthread.php?tid=3322 http://trilianforum.ir/entry.php?3-%DD%D1%E6%D4-%C8%98-%E1%26%231740%3B%E4%98p?98-Pl-maloy83 http://trollfun.ir/forum/index.php?threads/%D8%A7%D8%AA%D9%88%D8%A8%D8%A7%D8%B1-%D8%B1%D9%88%D8%B2-%D9%85%D8%B9%D8%AA%D8%A8%D8%B1-%D8%AF%D8%B1-%D8%A7%D9%85%D8%B1-%D8%AD%D9%85%D9%84-%D8%A8%D8%A7%D8%B1-%D8%AF%D8%B1-%D8%AA%D9%87%D8%B1%D8%A7%D9%86.24778/ http://trollfun.ir/forum/index.php?threads/5%D9%86%DA%A9%D8%AA%D9%87-%D8%A8%D8%B1%D8%A7%DB%8C-%D9%85%D8%AD%D8%A7%D9%81%D8%B8%D8%AA-%D8%A7%D8%B2-%D9%87%D8%A7%D8%B3%D8%AA-%D8%B3%DB%8C-%D9%BE%D9%86%D9%84.24396/ http://vls.jums.ac.ir/forum/index.php?members/tablooaraz.374/ http://vnsharing.site/forum/member.php?u=307792 http://voipforum.ir/member108.html http://westeros.ir/forum/viewtopic.php?f=20&t=14&p=23881 http://wfa.org.ir/threads/%D9%85%D8%B9%D8%B1%D9%81%DB%8C-%D8%B3%D8%A7%DB%8C%D8%AA-%D9%87%D8%A7%DB%8C-%D8%AF%D8%B1%D8%AC-%D8%A7%DA%AF%D9%87%DB%8C-%D8%B1%D8%A7%DB%8C%DA%AF%D8%A7%D9%86.130/ http://www.3dbuzz.com/forum/members/456289-tablooaraz http://www.aerocenter.ir/forum/blogs/tablooaraz/1230-backlink.html http://www.aerospacetalk.ir/vb/member.php?u=70948 http://www.airsoftgear.ca/member.php?1033-tablooaraz http://www.aramgroup.ir/Forum/members/tablooaraz/11-a.html http://www.ara-research.com/forum/showthread.php?tid=16 http://www.asapardazesh.ir/forum/entry.php?b=18 http://www.askquran.ir/member.php?u=88945 http://www.automationforum.vn/members/2332-tablooaraz http://www.ayehayeentezar.com/member10780.html http://www.beattips2.com/vb3/member.php?58844-tablooaraz http://www.bodoh.ir/showthread.php?t=7355 http://www.bourselar.ir/Forum/Post/807 http://www.buxnama.com/forum/thread-1611-post-5651.html http://www.cciran.ir/forum/showthread.php?1436-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9 http://www.classichorsemanship.com/member.php?u=3949 http://www.d2messageboard.com/member.php?u=51266 http://www.d3scene.com/forum/members/tablooaraz.html http://www.daneshju.ir/forum/member.php?u=382476 http://www.derby.ir/member.php?u=67288 http://www.developercenter.ir/forum/member.php?u=188358 http://www.developercenter.ir/forum/showthread.php?t=36580 http://www.drumsmoking.com/members/2496.html http://www.emdadgar.com/forum/showthread.php?pid=30174 http://www.esksfans.com/forum/member.php?21870-tablooaraz http://www.expeditioncolorado.net/forum/member/93-tablooaraz http://www.fafan.ir/topic/29-%D8%B7%D8%B1%D8%A7%D8%AD%DB%8C-%D8%B3%D8%A7%DB%8C%D8%AA-%DA%A9%D8%AA%D8%A7%D8%A8%D8%AE%D8%A7%D9%86%D9%87/ http://www.fifa-infinity.com/forums/member.php?u=13792 http://www.firemans.ir/Thread-%DA%A9%D8%AF%D8%A7%D9%85-%D8%AC%D8%B2%DB%8C%D8%B2%D9%87-%D8%B9%D8%B1%D9%88%D8%B3-%D8%B3%D9%88%D8%A7%D8%AD%D9%84-%D9%BE%D9%88%DA%A9%D8%AA-%D8%A7%D8%B3%D8%AA%D8%9F http://www.flashkhor.com/forum/showthread.php?tid=265184 http://www.fortress-forever.com/forums/member.php?u=20577 http://www.forum.canary98.ir/entry.php?b=14 http://www.forum.hostsaz.ir/thread-37-post-48.html http://www.forum.mybirds.ir/members/tablooaraz.html http://www.forum.parsbtc.com/showthread.php?2517-انواع-بک-لینک-با-کیفیت http://www.forum.zibatan.ir/members/tablooaraz-22185/ http://www.forums.downloadkral.com/entry.php?32621-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9-1 http://www.forums.mihandownload.com/member375804.html http://www.forzanocerina.it/forum/member.php?u=5592 http://www.gharian.ir/showthread.php?s=53f46c5a&tid=7211 http://www.hachiroku.com.au/forums/member.php?7638-tablooaraz http://www.heroes-networks.com/member/7808-tablooaraz http://www.highlander-community.com/forum/member/249-tablooaraz http://www.himt.ir/thread-4832-post-37578.html http://www.hobbyshop.ir/member.php?1136-tablooaraz http://www.iecloob.ir/showthread.php?tid=1514 http://www.iniuria.us/forum/member.php?138376-tablooaraz http://www.interbasket.net/forums/member.php?113314-tablooaraz http://www.i-phone.ir/forums/thread99980227.html http://www.iranamerica.com/forum/showthread.php?t=44456 http://www.iranamerica.com/forum/showthread.php?t=44499 http://www.iran-eng.ir/member.php/930500-tablooaraz http://www.iran-eng.ir/member.php/930500-tablooaraz http://www.iranianelite.com/members/tablooaraz-6197/ http://www.iranjoman.com/member-68538/ http://www.iranmicro.ir/forum/members/tablooaraz/ http://www.iranshahrsaz.com/member.php?action=profile&uid=109156 http://www.iranufc.biz/member5501.html http://www.iranufc.biz/member5501.html http://www.ir-eng.ir/f164/%D8%AA%D8%AE%D8%AA%D9%87-%D9%86%D8%B1%D8%AF-%D8%A8%D8%A7%D8%B2%DB%8C-%D8%A7%D8%B5%DB%8C%D9%84-%D8%A7%DB%8C%D8%B1%D8%A7%D9%86%DB%8C-11126.html http://www.irosclass.ir/tablooaraz/ http://www.ir-tci.org/forum/member.php?u=1275273 http://www.joomi.ir/forum/members/tablooaraz/ http://www.joomi.ir/forum/members/tablooaraz/ http://www.justih.org/Binder-Bench/member.php?u=17166 http://www.keshavarzirooz.ir/Forum/Post/21/ http://www.khatesefid.com/forum/showthread.php?530-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9 http://www.lawwiki.ir/forum/showthread.php?tid=3002 http://www.leatherneck.com/forums/member.php?123138-tablooaraz http://www.maidireborsa.it/member.php?462790-tablooaraz http://www.mbartar.ir/Forum/yaf_postsm20616_hmyt-hdyy-tblyGty-dr-khsb-w-khr-shm.aspx http://www.mellifera.ir/Forum/post30878.html http://www.migranthelp.com/phpbbfa/viewtopic.php?p=315559 http://www.mihangame.com/forum/member.php?u=3808 http://www.mihanwebhosting.com/forum/f44/15-%D8%A7%D8%B4%D8%AA%D8%A8%D8%A7%D9%87-%D8%AF%D8%B1-%D8%B7%D8%B1%D8%A7%D8%AD%DB%8C-%D8%B3%D8%A7%DB%8C%D8%AA-844/ http://www.my-fish.ir/Forum/Post/199 http://www.myl.ir/member.php?10-tablooaraz http://www.ncee2013.ir/Forum/Post/85/ http://www.northwestmagic.com/forums/member.php?u=10151 http://www.oil-eng.ir/member/335-tablooaraz http://www.oople.com/forums/member.php?u=25726 http://www.p30data.com/forum/showthread.php?66187-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9 http://www.pcbsupplies.co.uk/member.php/17993-tablooaraz http://www.pelletsmoking.com/blogs/tablooaraz-12236/backlink-4/ http://www.phorum.ir/thread-245-post-246.html http://www.phorum.ir/thread-474.html http://www.pmsclan.com/member/86143-tablooaraz http://www.raazebaghaa.org/forum/member.php?action=profile&uid=922 http://www.racechat.co.nz/horse/member.php?5001-tablooaraz http://www.roboyar.ir/forum/index.php/topic,91.0.html http://www.roozmenu.com/showthread.php?p=811249 http://www.runuo.net/forum/member/1542-tablooaraz http://www.sadafak.ir/f-33/%D8%AA%D9%81%D8%A7%D9%88%D8%AA-%D9%82%D8%A7%D8%B1%DA%86-%D9%86%D8%A7%D8%AE%D9%86-%D9%88-%D9%BE%D8%B3%D9%88%D8%B1%DB%8C%D8%A7%D8%B2%DB%8C%D8%B3-%D9%86%D8%A7%D8%AE%D9%86-324%20/ http://www.sanjeshy.org/forum/showthread.php?tid=21 http://www.sc2mafia.com/forum/member.php/30346-tablooaraz http://www.shadowera.com/member.php?98560-tablooaraz http://www.shahrsakhtafzar.com/forum/member.php?u=249204 http://www.slickdawg.com/member.php?951-tablooaraz http://www.support-wp.ir/f23/%D8%A7%D8%B1%D8%B3%D8%A7%D9%84-%D9%86%D9%88%D8%AA%DB%8C%D9%81%DB%8C%DA%A9%DB%8C%D8%B4%D9%86-4598/ http://www.tajerbank.com/forum/members/18848.html http://www.thermolife.com/forum/members/tablooaraz/ http://www.tollyclub.com/forums/member.php?2220-tablooaraz http://www.tollyclub.com/forums/member.php?2220-tablooaraz http://www.topforum.ir/threads/259669 http://www.urbangamers.net/forum/member.php?11900-tablooaraz http://www.vbiran.ir/members/tablooaraz/ http://www.vbiran.ir/weblogha/tablooaraz/1619-backlink.html http://www.vbiran.ir/weblogha/tablooaraz/1619-backlink.html http://www.visitorguard.com/forum/member/123-tablooaraz http://www.volvoxc.com/forums/member.php?61290-tablooaraz http://www.warofrightsforum.com/member.php?6043-tablooaraz http://www.webhostingtalk.af/member/44-tablooaraz http://www.weldeng.net/MyBB/Thread-طراحی-سایت-فروش-فایل http://www.wikivb.ir/member.php?u=13728 http://www.xebushanoi.com/forum/member.php?u=117908 http://www.yaalee.com/forums/member.php?u=4438 http://www.yekta-core.ir/members/tablooaraz.html http://yaran.us/member.php?148-tablooaraz http://yareghaeb.com/entry.php?b=36 http://yareghaeb.com/entry.php?b=37 http://yareghaeb.com/entry.php?b=38 http://yareghaeb.com/entry.php?b=39 http://yasbooks.com/Forum/post54.html https://arafarin.com/forum/topic/77-%D9%86%D8%B1%D9%85-%D8%A7%D9%81%D8%B2%D8%A7%D8%B1%D9%87%D8%A7%DB%8C-%D9%85%D9%88%D8%B1%D8%AF-%D9%86%DB%8C%D8%A7%D8%B2-%D8%A8%D8%B1%D8%A7%DB%8C-%D8%B7%D8%B1%D8%A7%D8%AD%DB%8C-%D8%B3%D8%A7%DB%8C%D8%AA/ https://ariadl.ir/member.php?u=139128 https://ariadl.ir/member.php?u=139128 https://aw.my.com/en/forum/member.php?525219-u_18271821 https://barnamenevisan.org/Forums/Post7652.html https://digielectric.com/forum/showthread.php?tid=15229 https://dotastage.ir/forum/members/110.html https://ekahroba.com/forum/members/821.html https://fishsniffer.com/forums/member.php?u=40342 https://forum.aev-conversions.com/member/35150-tablooaraz https://forum.azaronline.com/%D9%87%D8%A7%D8%B3%D8%AA-%D9%84%DB%8C%D9%86%D9%88%DA%A9%D8%B3/1308-%D9%88%DB%8C%DA%98%DA%AF%DB%8C-%D9%87%D8%A7%DB%8C-%D9%87%D8%A7%D8%B3%D8%AA-%D8%AE%D9%88%D8%A8.html https://forum.azaronline.com/members/tablooaraz.html https://forum.azaronline.com/members/tablooaraz.html https://forum.carx-tech.com/member/2762-tablooaraz https://forum.opencart.ir/member9473.html https://forum.p30web.org/members/12139 https://forum.parsiandownload.net/thread-16427.html https://forum.persianbax.ir/threads/%D8%B3%D8%A7%D9%84%D9%86-%D8%B2%DB%8C%D8%A8%D8%A7%DB%8C%DB%8C-%D8%B9%D8%B1%D9%88%D8%B3%DB%8C-%D8%AE%D9%88%D8%A8-%DB%8C%D8%A7-%D8%A8%D8%AF%D8%9F.36827/ https://forum.persiantools.com/threads/بینگ-وبمستر-چیست-؟.893695 https://forum.projectgorgon.com/member.php?1886-tablooaraz https://forum.scopely.com/member.php?56082-tablooaraz https://forum.slingshotroadsters.com/member/1767-tablooaraz https://forum.talarebourse.com/threads/%D9%87%D8%B2%DB%8C%D9%86%D9%87-%D8%A7%D8%B1%D8%AA%D9%88%D8%AF%D9%86%D8%B3%DB%8C.217988/ https://forum.zenstudios.com/member.php?282963-tablooaraz https://forums.animparadise.com/member.php?u=16561 https://forums.eagle.ru/member.php?u=130385 https://forums.sakhtafzarmag.com/members/27325-tablooaraz https://forums.sneakycrab.com/member/272-tablooaraz https://forums.viivo.com/member.php?6268-tablooaraz https://iranchip.ir/member/270-tablooaraz https://iripb.com/forums/topic/1583-%D9%85%D8%AD%D8%AA%D9%88%D8%A7%DB%8C-%D8%A7%D9%82%D8%AA%D8%A8%D8%A7%D8%B3%DB%8C-%DA%86%DB%8C%D8%B3%D8%AA/ https://japanbase.net/forum/member.php?1662-tablooaraz https://kleefa.ir/forums/showthread.php?tid=1419 https://kleefa.ir/forums/showthread.php?tid=1749 https://mamasite.ir/fa/forum/516985/%D8%A7%D9%86%D9%88%D8%A7%D8%B9-%D8%B7%D8%B1%D8%AD-%D8%B5%D9%86%D8%B9%D8%AA%DB%8C https://manesht.ir/forum/user-140615.html https://mihanscript.ir/forum/entry.php?22-%D9%81%D8%B1%D9%88%D8%B4-%D8%A8%DA%A9-%D9%84%DB%8C%D9%86%DA%A9-3 https://minitooti.ir/member.php?881-tablooaraz https://mmatorch.com/forum/member.php?2560-tablooaraz https://sefserver.com/forum/member.php?385-tablooaraz https://talk.patoghu.com/members/tablooaraz-u590824.html https://www.1forexforum.com/member.php?4545-baeveasuasda8070 https://www.buy-steroids.com.au/forum/member/3911-tablooaraz https://www.darksphere.co.uk/forum/member/57-tablooaraz https://www.downloadc3.com/forums/member.php?33109-tablooaraz https://www.gumbug.com/forum/member/237-tablooaraz https://www.happydays.ir/user-1442.html https://www.happydays.ir/user-1442.html#comments/1 https://www.hianzali.com/members/1296.html https://www.isarms.com/forums/members/tablooaraz.html https://www.nowaroos.com/Thread-%D8%AA%D8%B4%D8%B1%DB%8C%D9%81%D8%A7%D8%AA-%D8%B1%D9%86%D8%B3%D8%A7%D9%86%D8%B3-%DB%8C%D8%A7%D9%88%D8%B1%DB%8C--3372?pid=7455692#pid7455692 https://www.parsipet.ir/member.php?u=22918 https://www.parstuning.com/members/13666.html https://www.parstuning.com/members/13666.html https://www.pokecommunity.com/member.php?u=694922 https://www.roadnav.com/member/11362-tablooaraz https://www.tabletennisdaily.com/forum/member.php?42425-tablooaraz https://www.tarfandestan.com/forum/blogs/566595/blog15900.html https://www.tarfandestan.com/forum/member566595.html https://www.tarfandestan.com/forum/member566595.html 964355 275 cy 2017-12-20 01:12:14 +0000 ZFS Tuning (https://wiki.freebsd.org/ZFSTuningGuide -- some of which I had contributed) stated when it was written years ago setting vfs.zfs.arc_max, vm.kmem_size and vm.kmem_size_max for small memory machines. I'd been tuning my larger memory systems, albeit with higher values, avoiding the issues. Having removed the artificial limits, looking at the numbers (and I haven't studied this in depth), arc can shrink, but not easily. However the memory does remain wired. Without having a chance to look at any code I suspect there may be a couple of issues that might need to be addressed. (Juxtapositioned to this issue is the fact that UFS buffer cache doesn't readily shrink either.) What I'm suggesting is that we might need to take a step back and look at both issues holistically. 994912 276 eadler 2018-05-28 19:47:03 +0000 batch change: For bugs that match the following - Status Is In progress AND - Untouched since 2018-01-01. AND - Affects Base System OR Documentation DO: Reset to open status. Note: I did a quick pass but if you are getting this email it might be worthwhile to double check to see if this bug ought to be closed. 1012246 277 ian 2018-09-21 09:49:04 +0000 I have been seeing regular severe performance degradation due to 'WIRED' memory reaching 96G on a machine with 128G of physical ram, this is with arc_max set to 64G. The load on this machine is very static, it runs half a dozen bhyve vms, they run very well in general but see about a 70% drop in performance when the wired memory hits 95G or so. pagedaemon cpu goes from under 1% to sitting between 10% and 70%. After trying many things today trying to get it back under control without a reboot (including reducing arc_max to 20G and removing l2arc from the zpool completely), I wrote a quick and dirty bit of code to allocate 64G of ram and scan through at least 1 read in every 4K page. This pretty much instantly released much of the 95G of wired memory and returned performance to normal (and pagedaemon back to under 1% cpu). This might be a quick and dirty workaround for others experiencing this problem (I have parked this process in a 4am cron job for now). It does suggest though that the process of trimming back wired memory doesnt happen until way too late ? This is on 11.2 stable build around 15th of August. This machine repeatably degrades in performance around the same time, ie 3-4 weeks of uptime. I suspect with the dodgy program to just randomly eat up a bunch of ram and exit (it takes about 20 seconds to do this) running daily this degradation will not occur. Potentially on machines where there is more dynamic memory load this situation may not occur ? 1012391 278 FreeBSD 2018-09-22 03:23:28 +0000 (In reply to ian from comment #277) As well as arc being wired, there is also a max_wired that defaults to 30% ram, this limits other wired allocations, together the two can total more than physical ram. See bug #229764 for my report on that. You should also account for what ram your bhyves use, bhyve ram plus ARC plus max_wired should combine to less than physical. For the last two or three years I had been using an allocate memory script to push out arc fairly regularly, this is on my everyday desktop, I have not needed to since applying review D7538 1040107 279 ACCOUNT_DELETED 2019-03-02 11:24:58 +0000 See also: - bug 229670 - Too many vnodes causes ZFS ARC to exceed limit vfs.zfs.arc_max (high ARC "Other" usage) 1040126 280 karl 2019-03-02 14:58:07 +0000 (In reply to Graham Perrin from comment #279) Are you seeing this on FreeBSD-12? I've recently moved the system that had the worst examples of ARC trouble (and related), which led to my writing this patch originally to 12 -- and have not yet rolled the patch forward. SO FAR it appears that 12 is MUCH better behaved. There are fairly-extensive changes in the ZFS code internally in 12, and I'm not yet ready to call this OBE, but the improvement is substantial. Specifically, I could trivially trigger pathological behavior previously by simply starting a "buildworld" while that box was busy doing its other things (which include running a Postgres database) -- to the point that it would swap badly enough that interactive response was essentially destroyed. Poudriere was flat out of the question. I'm still seeing some evidence of leaving UMA in particular stale to some degree but it appears to be far better in 12 than it was previously. 1054891 281 seanc 2019-06-18 17:44:21 +0000 Karl, can you test 12 again with the following? https://svnweb.freebsd.org/base?view=revision&revision=348772 Given the age of this issue and other fixes in this area, I'm going to close this issue. If there is a new patch, let's create a new issue for a new patch that can be applied against master and potentially be MFC'ed or pushed upstream to OpenZFS (fka ZoL). 1054894 282 karl 2019-06-18 17:50:53 +0000 (In reply to Sean Chittenden from comment #281) I have a production box on FreeBSD 12.0-STABLE #2 r349024M at this point and will re-run my series of "torture tests" on it in the next couple of weeks -- am out of town right now. So far, however, since I built that rev it has not shown evidence of misbehavior. 1059317 283 vsasjason 2019-07-27 10:13:32 +0000 (In reply to Sean Chittenden from comment #281) I disagree with this since problem is still not fixed in releng/11.2, which is supported branch currently. 1059586 284 seanc 2019-07-29 17:45:26 +0000 (In reply to Anton Saietskii from comment #283) Raise the issue with re@ and see if they can cherry-pick the fixes into a supported branch. My understanding is such that MFC'ing the commits associated with this PR will not happen for 11-STABLE because the work is present in the 12-STABLE branch and because of the amount of drift between 1{1,2}-STABLE. 140882 2014-03-14 20:50:00 +0000 2014-03-14 20:50:00 +0000 file.diff file.diff text/plain 8444 karl KioqIC91c3Ivc3JjL3N5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96 ZnMvYXJjLmMJRnJpIE1hciAxNCAxNTozNjoxNyAyMDE0Ci0tLSBhcmMuYy5vcmlnaW5hbAlUaHUg TWFyIDEzIDA5OjE4OjQ4IDIwMTQKKioqKioqKioqKioqKioqCioqKiAxOCw4NSAqKioqCiAgICoK ICAgKiBDRERMIEhFQURFUiBFTkQKICAgKi8KLSAKLSAvKiBLYXJsIERlbm5pbmdlciAoa2FybEBk ZW5uaW5nZXIubmV0KSwgMy8xMy8yMDE0LCBGcmVlQlNELXNwZWNpZmljCi0gICogCi0gICogSWYg Ik5FV1JFQ0xBSU0iIGlzIGRlZmluZWQsIGNoYW5nZSB0aGUgImxvdyBtZW1vcnkiIHdhcm5pbmcg dGhhdCBjYXVzZXMKLSAgKiB0aGUgQVJDIGNhY2hlIHRvIGJlIHBhcmVkIGRvd24uICBUaGUgcmVh c29uIGZvciB0aGUgY2hhbmdlIGlzIHRoYXQgdGhlCi0gICogYXBwYXJlbnQgYXR0ZW1wdGVkIGFs Z29yaXRobSBpcyB0byBzdGFydCBldmljdGluZyBBUkMgY2FjaGUgd2hlbiBmcmVlCi0gICogcGFn ZXMgZmFsbCBiZWxvdyAyNSUgb2YgaW5zdGFsbGVkIFJBTS4gIFRoaXMgbWFwcyByZWFzb25hYmx5 IHdlbGwgdG8gaG93Ci0gICogU29sYXJpcyBpcyBkb2N1bWVudGVkIHRvIGJlaGF2ZTsgd2hlbiAi bG90c2ZyZWUiIGlzIGludmFkZWQgWkZTIGlzIHRvbGQgCi0gICogdG8gcGFyZSBkb3duLiAgCi0g ICoKLSAgKiBUaGUgcHJvYmxlbSBpcyB0aGF0IG9uIEZyZWVCU0QgbWFjaGluZXMgdGhlIHN5c3Rl bSBkb2Vzbid0IGFwcGVhciB0byBiZSAKLSAgKiBnZXR0aW5nIHdoYXQgdGhlIGF1dGhvcnMgb2Yg dGhlIG9yaWdpbmFsIGNvZGUgdGhvdWdodCB0aGV5IHdlcmUgbG9va2luZyBhdAotICAqIHdpdGgg aXRzIHRlc3QgYW5kIGFzIGEgcmVzdWx0IHRoYXQgdGVzdCBuZXZlciB0cmlnZ2Vycy4gIFRoYXQg bGVhdmVzIHRoZSAKLSAgKiBvbmx5IHJlY2xhaW0gdHJpZ2dlciBhcyB0aGUgInBhZ2luZyBuZWVk ZWQiIHN0YXR1cyBmbGFnLCBhbmQgYnkgdGhlIHRpbWUgCi0gICogdGhhdCB0cmlwcyB0aGUgc3lz dGVtIGlzIGFscmVhZHkgaW4gbG93LW1lbW9yeSB0cm91YmxlLiAgVGhpcyBjYW4gbGVhZCB0byAK LSAgKiBzZXZlcmUgcGF0aG9sb2dpY2FsIGJlaGF2aW9yIHVuZGVyIHRoZSBmb2xsb3dpbmcgc2Nl bmFyaW86Ci0gICogLSBUaGUgc3lzdGVtIHN0YXJ0cyB0byBwYWdlIGFuZCBBUkMgaXMgZXZpY3Rl ZC4KLSAgKiAtIFRoZSBzeXN0ZW0gc3RvcHMgcGFnaW5nIGFzIEFSQydzIGV2aWN0aW9uIGRyb3Bz IHdpcmVkIFJBTSBhIGJpdC4KLSAgKiAtIEFSQyBzdGFydHMgaW5jcmVhc2luZyBpdHMgYWxsb2Nh dGlvbiBhZ2FpbiwgYW5kIHdpcmVkIG1lbW9yeSBncm93cy4KLSAgKiAtIEEgbmV3IGltYWdlIGlz IGFjdGl2YXRlZCwgYW5kIHRoZSBzeXN0ZW0gb25jZSBhZ2FpbiBhdHRlbXB0cyB0byBwYWdlLgot ICAqIC0gQVJDIHN0YXJ0cyB0byBiZSBldmljdGVkIGFnYWluLgotICAqIC0gQmFjayB0byAjMgot ICAqIAotICAqIE5vdGUgdGhhdCBaRlMncyBBUkMgZGVmYXVsdCAodW5sZXNzIHlvdSBvdmVycmlk ZSBpdCBpbiAvYm9vdC9sb2FkZXIuY29uZikKLSAgKiBpcyB0byBhbGxvdyB0aGUgQVJDIGNhY2hl IHRvIGdyYWIgbmVhcmx5IGFsbCBvZiBmcmVlIFJBTSwgcHJvdmlkZWQgbm9ib2R5Ci0gICogZWxz ZSBuZWVkcyBpdC4gIFRoYXQgd291bGQgYmUgb2sgaWYgd2UgZXZpY3RlZCBjYWNoZSB3aGVuIHJl cXVpcmVkLgotICAqIAotICAqIFVuZm9ydHVuYXRlbHkgdGhlIHN5c3RlbSBjYW4gZ2V0IGludG8g YSBzdGF0ZSB3aGVyZSBpdCBuZXZlcgotICAqIG1hbmFnZXMgdG8gcGFnZSBhbnl0aGluZyBvZiBt YXRlcmlhbGl0eSBiYWNrIGluLCBhcyBpZiB0aGVyZSBpcyBhY3RpdmUKLSAgKiBJL08gdGhlIEFS QyB3aWxsIHN0YXJ0IGdyYWJiaW5nIHNwYWNlIG9uY2UgYWdhaW4gYXMgc29vbiBhcyB0aGUgbWVt b3J5IAotICAqIGNvbnRlbnRpb24gc3RhdGUgZHJvcHMuICBGb3IgdGhpcyByZWFzb24gdGhlICJw YWdpbmcgaXMgb2NjdXJyaW5nIiBmbGFnIAotICAqIHNob3VsZCBiZSB0aGUgKipsYXN0IHJlc29y dCoqIGNvbmRpdGlvbiBmb3IgQVJDIGV2aWN0aW9uOyB5b3Ugd2FudCB0byAKLSAgKiAoYXMgU29s YXJpcyBkb2VzKSBzdGFydCB3aGVuIHRoZXJlIGlzIG1hdGVyaWFsIGZyZWUgUkFNIGxlZnQgaW4g dGhlIGhvcGUgCi0gICogb2YgbmV2ZXIgZ2V0dGluZyBpbnRvIHRoZSBjb25kaXRpb24gd2hlcmUg eW91J3JlIHBvdGVudGlhbGx5IHBhZ2luZyBvZmYgCi0gICogZXhlY3V0YWJsZXMgaW4gZmF2b3Ig b2YgbGVhdmluZyBkaXNrIGNhY2hlIGFsbG9jYXRlZC4gIFRoYXQncyBhIHJlY2lwZSAKLSAgKiBm b3IgdGVycmlibGUgb3ZlcmFsbCBzeXN0ZW0gcGVyZm9ybWFuY2UuCi0gICoKLSAgKiBUbyBmaXgg dGhpcyB3ZSBpbnN0ZWFkIGdyYWIgZm91ciBPSURzIG91dCBvZiB0aGUgc3lzY3RsIHN0YXR1cwot ICAqIG1lc3NhZ2VzIC0tIHdpcmVkIHBhZ2VzLCBhY3RpdmUgcGFnZXMsIGluYWN0aXZlIHBhZ2Vz IGFuZCBjYWNoZSAodm5vZGVzPykKLSAgKiBwYWdlcywgc3VtIHRob3NlIGFuZCBjb21wYXJlIGFn YWluc3QgdGhlIGZyZWUgcGFnZSBjb3VudCBmcm9tIHRoZQotICAqIFZNIHN5c2N0bCBzdGF0dXMg T0lELCBnaXZpbmcgdXMgYSBwZXJjZW50YWdlIG9mIHBhZ2VzIGZyZWUuICBUaGlzCi0gICogaXMg Y2hlY2tlZCBhZ2FpbnN0IGEgbmV3IHR1bmFibGUgInZmcy56ZnMuYXJjX2ZyZWVwYWdlX3BlcmNl bnRfdGFyZ2V0IgotICAqIGFuZCBpZiBsZXNzLCB3ZSBkZWNsYXJlIHRoZSBzeXN0ZW0gbG93IG9u IG1lbW9yeS4KLSAgKiAKLSAgKiBOb3RlIHRoYXQgdGhpcyBzeXNjdGwgdmFyaWFibGUgaXMgcnVu dGltZSB0dW5hYmxlIGlmIHlvdSBoYXZlIHJlYXNvbgotICAqIHRvIGNoYW5nZSBpdCAoZS5nLiB5 b3Ugd2FudCBtb3JlIG9yIGxlc3MgUkFNIGZyZWUgdG8gYmUgdGhlICJjbGVhbiB1cCIKLSAgKiB0 aHJlc2hvbGQuKQotICAqCi0gICogSWYgd2UncmUgdXNpbmcgdGhpcyBjaGVjayBmb3IgbG93IG1l bW9yeSB3ZSBhcmUgcmVwbGFjaW5nIHRoZSBwcmV2aW91cwotICAqIG9uZXMsIGluY2x1ZGluZyB0 aGUgb2RkYmFsbCAicmFuZG9tIiByZWNsYWltIHRoYXQgYXBwZWFycyB0byBmaXJlIGZhcgotICAq IG1vcmUgb2Z0ZW4gdGhhbiBpdCBzaG91bGQuICBXZSBzdGlsbCB0cmlnZ2VyIGlmIHRoZSBzeXN0 ZW0gcGFnZXMuCi0gICoKLSAgKiBJZiB5b3UgdHVybiBvbiBORVdSRUNMQUlNX0RFQlVHIHRoZW4g dGhlIGtlcm5lbCB3aWxsIHByaW50IG9uIHRoZSBjb25zb2xlCi0gICogc3RhdHVzIG1lc3NhZ2Vz IHdoZW4gdGhlIHJlY2xhaW0gc3RhdHVzIHRyaXBzIG9uIGFuZCBvZmYsIGFsb25nIHdpdGggdGhl Ci0gICogcGFnZSBjb3VudCBhZ2dyZWdhdGUgdGhhdCB0cmlnZ2VyZWQgaXQgKGFuZCB0aGUgZnJl ZSBzcGFjZSkgZm9yIGVhY2gKLSAgKiBldmVudC4gCi0gICovCi0gCi0gI2RlZmluZQlORVdSRUNM QUlNCi0gI3VuZGVmCU5FV1JFQ0xBSU1fREVCVUcKLSAKLSAKICAvKgogICAqIENvcHlyaWdodCAo YykgMjAwNSwgMjAxMCwgT3JhY2xlIGFuZC9vciBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KICAgKiBDb3B5cmlnaHQgKGMpIDIwMTMgYnkgRGVscGhpeC4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KLS0tIDE4LDIzIC0tLS0KKioqKioqKioqKioqKioqCioqKiAyMDEsMjEyICoqKioK ICAKICAjaW5jbHVkZSA8dm0vdm1fcGFnZW91dC5oPgogIAotICNpZmRlZglORVdSRUNMQUlNCi0g I2lmZGVmCV9fRnJlZUJTRF9fCi0gI2luY2x1ZGUgPHN5cy9zeXNjdGwuaD4KLSAjZW5kaWYKLSAj ZW5kaWYJLyogTkVXUkVDTEFJTSAqLwotIAogICNpZmRlZiBpbGx1bW9zCiAgI2lmbmRlZiBfS0VS TkVMCiAgLyogc2V0IHdpdGggWkZTX0RFQlVHPXdhdGNoLCB0byBlbmFibGUgd2F0Y2hwb2ludHMg b24gZnJvemVuIGJ1ZmZlcnMgKi8KLS0tIDEzOSwxNDQgLS0tLQoqKioqKioqKioqKioqKioKKioq IDI3MSwzMDMgKioqKgogIGludCB6ZnNfYXJjX3Nocmlua19zaGlmdCA9IDA7CiAgaW50IHpmc19h cmNfcF9taW5fc2hpZnQgPSAwOwogIGludCB6ZnNfZGlzYWJsZV9kdXBfZXZpY3Rpb24gPSAwOwot ICNpZmRlZglORVdSRUNMQUlNCi0gI2lmZGVmICBfX0ZyZWVCU0RfXwotIHN0YXRpYwlpbnQgcGVy Y2VudF90YXJnZXQgPSAyNTsKLSAjZW5kaWYKLSAjZW5kaWYKICAKICBUVU5BQkxFX1FVQUQoInZm cy56ZnMuYXJjX21heCIsICZ6ZnNfYXJjX21heCk7CiAgVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFy Y19taW4iLCAmemZzX2FyY19taW4pOwogIFRVTkFCTEVfUVVBRCgidmZzLnpmcy5hcmNfbWV0YV9s aW1pdCIsICZ6ZnNfYXJjX21ldGFfbGltaXQpOwotICNpZmRlZglORVdSRUNMQUlNCi0gI2lmZGVm ICBfX0ZyZWVCU0RfXwotIFRVTkFCTEVfSU5UKCJ2ZnMuemZzLmFyY19mcmVlcGFnZV9wZXJjZW50 X3RhcmdldCIsICZwZXJjZW50X3RhcmdldCk7Ci0gI2VuZGlmCi0gI2VuZGlmCi0gCiAgU1lTQ1RM X0RFQ0woX3Zmc196ZnMpOwogIFNZU0NUTF9VUVVBRChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19t YXgsIENUTEZMQUdfUkRUVU4sICZ6ZnNfYXJjX21heCwgMCwKICAgICAgIk1heGltdW0gQVJDIHNp emUiKTsKICBTWVNDVExfVVFVQUQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfbWluLCBDVExGTEFH X1JEVFVOLCAmemZzX2FyY19taW4sIDAsCiAgICAgICJNaW5pbXVtIEFSQyBzaXplIik7CiAgCi0g I2lmZGVmCU5FV1JFQ0xBSU0KLSAjaWZkZWYgIF9fRnJlZUJTRF9fCi0gU1lTQ1RMX0lOVChfdmZz X3pmcywgT0lEX0FVVE8sIGFyY19mcmVlcGFnZV9wZXJjZW50X3RhcmdldCwgQ1RMRkxBR19SV1RV TiwgJnBlcmNlbnRfdGFyZ2V0LCAwLCAiQVJDIEZyZWUgUkFNIFRhcmdldCBwZXJjZW50YWdlIik7 Ci0gI2VuZGlmCi0gI2VuZGlmCi0gCiAgLyoKICAgKiBOb3RlIHRoYXQgYnVmZmVycyBjYW4gYmUg aW4gb25lIG9mIDYgc3RhdGVzOgogICAqCUFSQ19hbm9uCS0gYW5vbnltb3VzIChkaXNjdXNzZWQg YmVsb3cpCi0tLSAyMDMsMjE4IC0tLS0KKioqKioqKioqKioqKioqCioqKiAyNTIzLDI1NDQgKioq KgogIHsKICAKICAjaWZkZWYgX0tFUk5FTAotICNpZmRlZglORVdSRUNMQUlNCi0gI2lmZGVmICBf X0ZyZWVCU0RfXwotICAgICAgICAgdV9pbnQJdm13aXJlID0gMDsKLSAJdV9pbnQJdm1hY3RpdmUg PSAwOwotIAl1X2ludAl2bWluYWN0aXZlID0gMDsKLSAJdV9pbnQJdm1jYWNoZSA9IDA7Ci0gCXVf aW50CXZtZnJlZSA9IDA7Ci0gCXVfaW50CXZtdG90YWwgPSAwOwotIAlpbnQJcGVyY2VudCA9IDI1 OwotIAlzaXplX3QJdm1zaXplOwotICNpZmRlZglORVdSRUNMQUlNX0RFQlVHCi0gCXN0YXRpYwlp bnQJeHZhbCA9IC0xOwotIAlzdGF0aWMJaW50CW9sZHBlcmNlbnQgPSAwOwotICNlbmRpZgkvKiBO RVdSRUNMQUlNX0RFQlVHICovCi0gI2VuZGlmCS8qIE5FV1JFQ0xBSU0gKi8KLSAjZW5kaWYKICAK ICAJaWYgKG5lZWRmcmVlKQogIAkJcmV0dXJuICgxKTsKLS0tIDI0MzgsMjQ0MyAtLS0tCioqKioq KioqKioqKioqKgoqKiogMjU3NywyNTgzICoqKioKICAJCXJldHVybiAoMSk7CiAgCiAgI2lmIGRl ZmluZWQoX19pMzg2KQotIAogIAkvKgogIAkgKiBJZiB3ZSdyZSBvbiBhbiBpMzg2IHBsYXRmb3Jt LCBpdCdzIHBvc3NpYmxlIHRoYXQgd2UnbGwgZXhoYXVzdCB0aGUKICAJICoga2VybmVsIGhlYXAg c3BhY2UgYmVmb3JlIHdlIGV2ZXIgcnVuIG91dCBvZiBhdmFpbGFibGUgcGh5c2ljYWwKLS0tIDI0 NzYsMjQ4MSAtLS0tCioqKioqKioqKioqKioqKgoqKiogMjU5NCwyNjU5ICoqKioKICAJCXJldHVy biAoMSk7CiAgI2VuZGlmCiAgI2Vsc2UJLyogIXN1biAqLwotIAotICNpZmRlZglORVdSRUNMQUlN Ci0gI2lmZGVmICBfX0ZyZWVCU0RfXwotIC8qCi0gICogSW1wbGVtZW50IHRoZSBuZXcgdHVuYWJs ZSBmcmVlIFJBTSBhbGdvcml0aG0uICBXZSBjaGVjayB0aGUgdmFyaW91cyBwYWdlCi0gICogVk0g c3RhdHMgYW5kIGFkZCB0aGVtIHVwLCB0aGVuIGNoZWNrIHRoZSBmcmVlIGNvdW50IHBlcmNlbnRh Z2UgYWdhaW5zdAotICAqIHRoZSBzcGVjaWZpZWQgdGFyZ2V0LiAgSWYgd2UncmUgdW5kZXIgdGhl IHRhcmdldCB3ZSBhcmUgbWVtb3J5IGNvbnN0cmFpbmVkCi0gICogYW5kIGFzayBmb3IgQVJDIGNh Y2hlIHNocmlua2FnZS4gIElmIHRoaXMgaXMgZGVmaW5lZCBvbiBhIEZyZWVCU0Qgc3lzdGVtCi0g ICogdGhlIG9sZGVyIGNoZWNrcyBhcmUgbm90IHBlcmZvcm1lZC4KLSAgKi8KLSAJdm1zaXplID0g c2l6ZW9mKHZtd2lyZSk7Ci0gICAgICAgICBrZXJuZWxfc3lzY3RsYnluYW1lKGN1cnRocmVhZCwg InZtLnN0YXRzLnZtLnZfd2lyZV9jb3VudCIsICZ2bXdpcmUsICZ2bXNpemUsIE5VTEwsIDAsIE5V TEwsIDApOwotIAl2bXNpemUgPSBzaXplb2Yodm1hY3RpdmUpOwotICAgICAgICAga2VybmVsX3N5 c2N0bGJ5bmFtZShjdXJ0aHJlYWQsICJ2bS5zdGF0cy52bS52X2FjdGl2ZV9jb3VudCIsICZ2bWFj dGl2ZSwgJnZtc2l6ZSwgTlVMTCwgMCwgTlVMTCwgMCk7Ci0gCXZtc2l6ZSA9IHNpemVvZih2bWlu YWN0aXZlKTsKLSAgICAgICAgIGtlcm5lbF9zeXNjdGxieW5hbWUoY3VydGhyZWFkLCAidm0uc3Rh dHMudm0udl9pbmFjdGl2ZV9jb3VudCIsICZ2bWluYWN0aXZlLCAmdm1zaXplLCBOVUxMLCAwLCBO VUxMLCAwKTsKLSAJdm1zaXplID0gc2l6ZW9mKHZtY2FjaGUpOwotICAgICAgICAga2VybmVsX3N5 c2N0bGJ5bmFtZShjdXJ0aHJlYWQsICJ2bS5zdGF0cy52bS52X2NhY2hlX2NvdW50IiwgJnZtY2Fj aGUsICZ2bXNpemUsIE5VTEwsIDAsIE5VTEwsIDApOwotIAl2bXNpemUgPSBzaXplb2Yodm1mcmVl KTsKLSAgICAgICAgIGtlcm5lbF9zeXNjdGxieW5hbWUoY3VydGhyZWFkLCAidm0uc3RhdHMudm0u dl9mcmVlX2NvdW50IiwgJnZtZnJlZSwgJnZtc2l6ZSwgTlVMTCwgMCwgTlVMTCwgMCk7Ci0gCXZt c2l6ZSA9IHNpemVvZihwZXJjZW50KTsKLSAgICAgICAgIGtlcm5lbF9zeXNjdGxieW5hbWUoY3Vy dGhyZWFkLCAidmZzLnpmcy5hcmNfZnJlZXBhZ2VfcGVyY2VudF90YXJnZXQiLCAmcGVyY2VudCwg JnZtc2l6ZSwgTlVMTCwgMCwgTlVMTCwgMCk7Ci0gCXZtdG90YWwgPSB2bXdpcmUgKyB2bWFjdGl2 ZSArIHZtaW5hY3RpdmUgKyB2bWNhY2hlICsgdm1mcmVlOwotICNpZmRlZglORVdSRUNMQUlNX0RF QlVHCi0gCWlmIChwZXJjZW50ICE9IG9sZHBlcmNlbnQpIHsKLSAJCXByaW50ZigiWkZTIEFSQzog UmVzZXJ2YXRpb24gY2hhbmdlIHRvIFslZF0sIFslZF0gcGFnZXMsIFslZF0gZnJlZVxuIiwgcGVy Y2VudCwgdm10b3RhbCwgdm1mcmVlKTsKLSAJCW9sZHBlcmNlbnQgPSBwZXJjZW50OwotIAl9Ci0g I2VuZGlmCi0gCi0gCWlmICghdm10b3RhbCkgewotIAkJdm10b3RhbCA9IDE7CS8qIFByb3RlY3Qg YWdhaW5zdCBkaXZpZGUgYnkgemVybyAqLwotIAkJCQkvKiAoc2hvdWxkIGJlIGltcG9zc2libGUs IGJ1dC4uLikgKi8KLSAJfQotIAotIAlpZiAoKCh2bWZyZWUgKiAxMDApIC8gdm10b3RhbCkgPCBw ZXJjZW50KSB7Ci0gI2lmZGVmCU5FV1JFQ0xBSU1fREVCVUcKLSAJCWlmICh4dmFsICE9IDEpIHsK LSAJCQlwcmludGYoIlpGUyBBUkM6IFJFQ0xBSU0gdG90YWwgJXUsIGZyZWUgJXUsIGZyZWUgcGN0 ICgldSksIHRhcmdldCBwY3QgKCV1KVxuIiwgdm10b3RhbCwgdm1mcmVlLCAoKHZtZnJlZSAqIDEw MCkgLyB2bXRvdGFsKSwgcGVyY2VudCk7Ci0gCQkJeHZhbCA9IDE7Ci0gCQl9Ci0gI2VuZGlmCS8q IE5FV1JFQ0xBSU1fREVCVUcgKi8KLSAJCXJldHVybigxKTsKLSAJfSBlbHNlIHsKLSAjaWZkZWYJ TkVXUkVDTEFJTV9ERUJVRwotIAkJaWYgKHh2YWwgIT0gMCkgewotIAkJCXByaW50ZigiWkZTIEFS QzogTk9STUFMIHRvdGFsICV1LCBmcmVlICV1LCBmcmVlIHBjdCAoJXUpLCB0YXJnZXQgcGN0ICgl dSlcbiIsIHZtdG90YWwsIHZtZnJlZSwgKCh2bWZyZWUgKiAxMDApIC8gdm10b3RhbCksIHBlcmNl bnQpOwotIAkJCXh2YWwgPSAwOwotIAkJfQotICNlbmRpZgotIAkJcmV0dXJuKDApOwotIAl9Ci0g Ci0gI2VuZGlmCS8qIF9fRnJlZUJTRF9fICovCi0gI2VuZGlmCS8qIE5FV1JFQ0xBSU0gKi8KLSAK ICAJaWYgKGttZW1fdXNlZCgpID4gKGttZW1fc2l6ZSgpICogMykgLyA0KQogIAkJcmV0dXJuICgx KTsKICAjZW5kaWYJLyogc3VuICovCiAgCiAgCWlmIChzcGFfZ2V0X3JhbmRvbSgxMDApID09IDAp CiAgCQlyZXR1cm4gKDEpOwogICNlbmRpZgotLS0gMjQ5MiwyNTAyIC0tLS0KICAJCXJldHVybiAo MSk7CiAgI2VuZGlmCiAgI2Vsc2UJLyogIXN1biAqLwogIAlpZiAoa21lbV91c2VkKCkgPiAoa21l bV9zaXplKCkgKiAzKSAvIDQpCiAgCQlyZXR1cm4gKDEpOwogICNlbmRpZgkvKiBzdW4gKi8KICAK KyAjZWxzZQogIAlpZiAoc3BhX2dldF9yYW5kb20oMTAwKSA9PSAwKQogIAkJcmV0dXJuICgxKTsK ICAjZW5kaWY= 140883 2014-03-19 14:18:40 +0000 2014-08-24 09:05:40 +0000 smime.p7s smime.p7s application/pkcs7-signature 2711 karl MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIIFTzCCBUsw ggQzoAMCAQICAQgwDQYJKoZIhvcNAQEFBQAwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9y aWRhMRIwEAYDVQQHEwlOaWNldmlsbGUxGTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNV BAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0ExLzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VA Y3VkYXN5c3RlbXMubmV0MB4XDTEzMDgyNDE5MDM0NFoXDTE4MDgyMzE5MDM0NFowWzELMAkGA1UE BhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExFzAVBgNVBAMTDkthcmwgRGVubmluZ2VyMSEwHwYJKoZI hvcNAQkBFhJrYXJsQGRlbm5pbmdlci5uZXQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC AQC5n2KBrBmG22nVntVdvgKCB9UcnapNThrW1L+dq6thd9l4mj+qYMUpJ+8I0rTbY1dn21IXQBoB Qmy8t1doKwmTdQ59F0FwZEPt/fGbRgBKVt3Quf6W6n7kRk9MG6gdD7V9vPpFV41e+5MWYtqGWY3S cDP8SyYLjL/Xgr+5KFKkDfuubK8DeNqdLniVjHo/vqmIgO+6NgzPGPgmbutzFQXlxUqjiNAAKzF2 +Tkddi+WKABrcc/EqnBb0X8GdqcIamO5SyVmuM+7Zdns7D9pcV16zMMQ8LfNFQCDvbCuuQKMDg2F 22x5ekYXpwjqTyfjcHBkWC8vFNoY5aFMdyiN/Kkz0/kduP2ekYOgkRqcShfLEcG9SQ4LQZgqjMpT jSOGzBr3tOvVn5LkSJSHW2Z8Q0dxSkvFG2/lsOWFbwQeeZSaBi5vRZCYCOf5tRd1+E93FyQfpt4v srXshIAk7IK7f0qXvxP4GDli5PKIEubD2Bn+gp3vB/DkfKySh5NBHVB+OPCoXRUWBkQxme65wBO0 2OZZt0k8Iq0i4RciWV6z+lQHqDKtaVGgMsHn6PoeYhjf5Al5SP+U3imTjF2aCca1iDB5JOccX04M NljvifXgcbJNnkMgrzmm1ZgJ1PLur/ADWPlnz45quOhHg1TfUCLfI/DzgG7Z6u+oy4siQuFr9QT0 MQIDAQABo4HWMIHTMAkGA1UdEwQCMAAwEQYJYIZIAYb4QgEBBAQDAgWgMAsGA1UdDwQEAwIF4DAs BglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFHw4 +LnuALyLA5Cgy7T5ZAX1WzKPMB8GA1UdIwQYMBaAFF3U3hpBZq40HB5VM7B44/gmXiI0MDgGCWCG SAGG+EIBAwQrFilodHRwczovL2N1ZGFzeXN0ZW1zLm5ldDoxMTQ0My9yZXZva2VkLmNybDANBgkq hkiG9w0BAQUFAAOCAQEAZ0L4tQbBd0hd4wuw/YVqEBDDXJ54q2AoqQAmsOlnoxLO31ehM/LvrTIP 4yK2u1VmXtUumQ4Ao15JFM+xmwqtEGsh70RRrfVBAGd7KOZ3GB39FP2TgN/cL5fJKVxOqvEnW6cL 9QtvUlcM3hXg8kDv60OB+LIcSE/P3/s+0tEpWPjxm3LHVE7JmPbZIcJ1YMoZvHh0NSjY5D0HZlwt bDO7pDz9sZf1QEOgjH828fhtborkaHaUI46pmrMjiBnY6ujXMcWDpxtikki0zY22nrxfTs5xDWGx yrc/cmucjxClJF6+OYVUSaZhiiHfa9Pr+41okLgsRB0AmNwEf6ItY3TI8DGCBQowggUGAgEBMIGj MIGdMQswCQYDVQQGEwJVUzEQMA4GA1UECBMHRmxvcmlkYTESMBAGA1UEBxMJTmljZXZpbGxlMRkw FwYDVQQKExBDdWRhIFN5c3RlbXMgTExDMRwwGgYDVQQDExNDdWRhIFN5c3RlbXMgTExDIENBMS8w LQYJKoZIhvcNAQkBFiBjdXN0b21lci1zZXJ2aWNlQGN1ZGFzeXN0ZW1zLm5ldAIBCDAJBgUrDgMC GgUAoIICOzAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcBMBwGCSqGSIb3DQEJBTEPFw0xNDAzMTkx NDE4NDBaMCMGCSqGSIb3DQEJBDEWBBQei71KWp0Us3DWHQWNCkeF3NMHRjBsBgkqhkiG9w0BCQ8x XzBdMAsGCWCGSAFlAwQBKjALBglghkgBZQMEAQIwCgYIKoZIhvcNAwcwDgYIKoZIhvcNAwICAgCA MA0GCCqGSIb3DQMCAgFAMAcGBSsOAwIHMA0GCCqGSIb3DQMCAgEoMIG0BgkrBgEEAYI3EAQxgaYw gaMwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9yaWRhMRIwEAYDVQQHEwlOaWNldmlsbGUx GTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNVBAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0Ex LzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VAY3VkYXN5c3RlbXMubmV0AgEIMIG2Bgsq hkiG9w0BCRACCzGBpqCBozCBnTELMAkGA1UEBhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExEjAQBgNV BAcTCU5pY2V2aWxsZTEZMBcGA1UEChMQQ3VkYSBTeXN0ZW1zIExMQzEcMBoGA1UEAxMTQ3VkYSBT eXN0ZW1zIExMQyBDQTEvMC0GCSqGSIb3DQEJARYgY3VzdG9tZXItc2VydmljZUBjdWRhc3lzdGVt cy5uZXQCAQgwDQYJKoZIhvcNAQEBBQAEggIAYM3wX4zcQ6slDGipG999HQbbYlLYwEaJRr1wTMOU oP+KPdDpxP9hJ6lOJYbiaM98HM1mSjxEvyX6kydwbKvV9QKVld7dliA2+pTyyH7ZlVdVKgtYWH6J 03fjyIIdZaFHpAfSVmHeoNxKvgVZ27ur0cLs5VG+BcOeW37JctenhidfH2XMs5DgCQMcn2ZcUqM7 ncq3zPQu5K3afxcrmFhkrvKoeUgiLnZtERGHKClhdhQHthOGjaPaWShUih/yJoDcsEeuOOio4wQ3 mM7DIwvn2F4B/hL90NIM0VLW95NyeJJ2TjbMa8kQ2tSv+PC3NPXNCJRv6wONUT3i+U+9Dl69sJVr LmfXku+vbXFb7VirsEN7WP8x7ABX6TA3WIDNTy+RMcMxEmYim5pmLId5h3s72b48vR/ptwPrAmxr QOaLPt5kKkRxZ4D4uTQb0+XPtAFJKEhGCQyEQ86n4b7Kzskoucm2UWx78uMUPD6eSiWdvv0AtnkY ULhnPAErNz2t1hnpmsJK23dDZQfyIYRDxc8Q3UZX2KVyyD/gnq3G3JNDj5zayedh2f08bCPKBqoY UbWnhY0rtkyCdWaL3zz+CXGqnT8Kp/wFUan14xdvVyETg6xXOLxFAYIj16nXS/gjWm45oyhEGlT0 GcKCBcjK8V46KuXqwqZ1k5ojKWYVAfZPB7YAAAAAAAA= 140884 2014-03-19 18:03:30 +0000 2014-08-24 09:05:40 +0000 smime.p7s smime.p7s application/pkcs7-signature 2711 karl MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIIFTzCCBUsw ggQzoAMCAQICAQgwDQYJKoZIhvcNAQEFBQAwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9y aWRhMRIwEAYDVQQHEwlOaWNldmlsbGUxGTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNV BAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0ExLzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VA Y3VkYXN5c3RlbXMubmV0MB4XDTEzMDgyNDE5MDM0NFoXDTE4MDgyMzE5MDM0NFowWzELMAkGA1UE BhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExFzAVBgNVBAMTDkthcmwgRGVubmluZ2VyMSEwHwYJKoZI hvcNAQkBFhJrYXJsQGRlbm5pbmdlci5uZXQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC AQC5n2KBrBmG22nVntVdvgKCB9UcnapNThrW1L+dq6thd9l4mj+qYMUpJ+8I0rTbY1dn21IXQBoB Qmy8t1doKwmTdQ59F0FwZEPt/fGbRgBKVt3Quf6W6n7kRk9MG6gdD7V9vPpFV41e+5MWYtqGWY3S cDP8SyYLjL/Xgr+5KFKkDfuubK8DeNqdLniVjHo/vqmIgO+6NgzPGPgmbutzFQXlxUqjiNAAKzF2 +Tkddi+WKABrcc/EqnBb0X8GdqcIamO5SyVmuM+7Zdns7D9pcV16zMMQ8LfNFQCDvbCuuQKMDg2F 22x5ekYXpwjqTyfjcHBkWC8vFNoY5aFMdyiN/Kkz0/kduP2ekYOgkRqcShfLEcG9SQ4LQZgqjMpT jSOGzBr3tOvVn5LkSJSHW2Z8Q0dxSkvFG2/lsOWFbwQeeZSaBi5vRZCYCOf5tRd1+E93FyQfpt4v srXshIAk7IK7f0qXvxP4GDli5PKIEubD2Bn+gp3vB/DkfKySh5NBHVB+OPCoXRUWBkQxme65wBO0 2OZZt0k8Iq0i4RciWV6z+lQHqDKtaVGgMsHn6PoeYhjf5Al5SP+U3imTjF2aCca1iDB5JOccX04M NljvifXgcbJNnkMgrzmm1ZgJ1PLur/ADWPlnz45quOhHg1TfUCLfI/DzgG7Z6u+oy4siQuFr9QT0 MQIDAQABo4HWMIHTMAkGA1UdEwQCMAAwEQYJYIZIAYb4QgEBBAQDAgWgMAsGA1UdDwQEAwIF4DAs BglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFHw4 +LnuALyLA5Cgy7T5ZAX1WzKPMB8GA1UdIwQYMBaAFF3U3hpBZq40HB5VM7B44/gmXiI0MDgGCWCG SAGG+EIBAwQrFilodHRwczovL2N1ZGFzeXN0ZW1zLm5ldDoxMTQ0My9yZXZva2VkLmNybDANBgkq hkiG9w0BAQUFAAOCAQEAZ0L4tQbBd0hd4wuw/YVqEBDDXJ54q2AoqQAmsOlnoxLO31ehM/LvrTIP 4yK2u1VmXtUumQ4Ao15JFM+xmwqtEGsh70RRrfVBAGd7KOZ3GB39FP2TgN/cL5fJKVxOqvEnW6cL 9QtvUlcM3hXg8kDv60OB+LIcSE/P3/s+0tEpWPjxm3LHVE7JmPbZIcJ1YMoZvHh0NSjY5D0HZlwt bDO7pDz9sZf1QEOgjH828fhtborkaHaUI46pmrMjiBnY6ujXMcWDpxtikki0zY22nrxfTs5xDWGx yrc/cmucjxClJF6+OYVUSaZhiiHfa9Pr+41okLgsRB0AmNwEf6ItY3TI8DGCBQowggUGAgEBMIGj MIGdMQswCQYDVQQGEwJVUzEQMA4GA1UECBMHRmxvcmlkYTESMBAGA1UEBxMJTmljZXZpbGxlMRkw FwYDVQQKExBDdWRhIFN5c3RlbXMgTExDMRwwGgYDVQQDExNDdWRhIFN5c3RlbXMgTExDIENBMS8w LQYJKoZIhvcNAQkBFiBjdXN0b21lci1zZXJ2aWNlQGN1ZGFzeXN0ZW1zLm5ldAIBCDAJBgUrDgMC GgUAoIICOzAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcBMBwGCSqGSIb3DQEJBTEPFw0xNDAzMTkx ODAzMzBaMCMGCSqGSIb3DQEJBDEWBBSFyxvPVuD9KQx+MckyjGvGxg/wgzBsBgkqhkiG9w0BCQ8x XzBdMAsGCWCGSAFlAwQBKjALBglghkgBZQMEAQIwCgYIKoZIhvcNAwcwDgYIKoZIhvcNAwICAgCA MA0GCCqGSIb3DQMCAgFAMAcGBSsOAwIHMA0GCCqGSIb3DQMCAgEoMIG0BgkrBgEEAYI3EAQxgaYw gaMwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9yaWRhMRIwEAYDVQQHEwlOaWNldmlsbGUx GTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNVBAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0Ex LzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VAY3VkYXN5c3RlbXMubmV0AgEIMIG2Bgsq hkiG9w0BCRACCzGBpqCBozCBnTELMAkGA1UEBhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExEjAQBgNV BAcTCU5pY2V2aWxsZTEZMBcGA1UEChMQQ3VkYSBTeXN0ZW1zIExMQzEcMBoGA1UEAxMTQ3VkYSBT eXN0ZW1zIExMQyBDQTEvMC0GCSqGSIb3DQEJARYgY3VzdG9tZXItc2VydmljZUBjdWRhc3lzdGVt cy5uZXQCAQgwDQYJKoZIhvcNAQEBBQAEggIAPdSjbOwT77SmBWi5+zg+Jonbc/Lb7lyt9dX3xR2x X8Bkxa6HS/n0DjQ+vvNQSUOthkjzmlFs53EbSVuhMQGFfXYJOmeB7oBeRPzRVXUl2X8zgajok9Sj KCkeV0Wx2yHCW+cMc/k5e0dDU6QCH05d26qbaEp0iOG7T0SAcdZagFKvEHOCYvCtDI7kzajdSQOA wp4JsuBpHO4Bx+h6dn8MleeCm229cKl5rVbVM4KkBXECDzJ8vu05ggfisQKeJzKVyMwFvkVlZtN5 4Sf2Vy70X/S0wYIMeopHFe18Ua1mpfUrG+FlvDVrxb0XawV+L52GKFTVWAhdYzflZdonkZP2cU3l uJuhLVo4GQL6CMQnmV8YhREoBZYlsaa6A4HYcWjuy8kCrUohrgDQTdlG3KXbLksQ8joEc2lp79QA wF7c4+ggUVqFIbE8YiYvr0lJCxEce8BF3pVknNcMoF8tsIac3LnHj5fdmogToohf4vCC+UA6DL3e L5PMpQT7RdwaYqrZbcNGKcSSB1H662trqceVyO7vDDzkEwu5bh3afW88Q9vEIr21LcMi75cZn1FR p3TmIWNVZboop9MCGpKSMenqDtAkDSCYex+IBP3eEsoDtNfNDQCAbC3vO9stQVYKwPvPNng4FlwF SkxXsQ1urRL6XK3LwHC0RO3B4DLhNt8StxkAAAAAAAA= 140885 2014-03-20 12:26:39 +0000 2014-08-24 09:05:40 +0000 smime.p7s smime.p7s application/pkcs7-signature 2711 karl MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIIFTzCCBUsw ggQzoAMCAQICAQgwDQYJKoZIhvcNAQEFBQAwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9y aWRhMRIwEAYDVQQHEwlOaWNldmlsbGUxGTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNV BAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0ExLzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VA Y3VkYXN5c3RlbXMubmV0MB4XDTEzMDgyNDE5MDM0NFoXDTE4MDgyMzE5MDM0NFowWzELMAkGA1UE BhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExFzAVBgNVBAMTDkthcmwgRGVubmluZ2VyMSEwHwYJKoZI hvcNAQkBFhJrYXJsQGRlbm5pbmdlci5uZXQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC AQC5n2KBrBmG22nVntVdvgKCB9UcnapNThrW1L+dq6thd9l4mj+qYMUpJ+8I0rTbY1dn21IXQBoB Qmy8t1doKwmTdQ59F0FwZEPt/fGbRgBKVt3Quf6W6n7kRk9MG6gdD7V9vPpFV41e+5MWYtqGWY3S cDP8SyYLjL/Xgr+5KFKkDfuubK8DeNqdLniVjHo/vqmIgO+6NgzPGPgmbutzFQXlxUqjiNAAKzF2 +Tkddi+WKABrcc/EqnBb0X8GdqcIamO5SyVmuM+7Zdns7D9pcV16zMMQ8LfNFQCDvbCuuQKMDg2F 22x5ekYXpwjqTyfjcHBkWC8vFNoY5aFMdyiN/Kkz0/kduP2ekYOgkRqcShfLEcG9SQ4LQZgqjMpT jSOGzBr3tOvVn5LkSJSHW2Z8Q0dxSkvFG2/lsOWFbwQeeZSaBi5vRZCYCOf5tRd1+E93FyQfpt4v srXshIAk7IK7f0qXvxP4GDli5PKIEubD2Bn+gp3vB/DkfKySh5NBHVB+OPCoXRUWBkQxme65wBO0 2OZZt0k8Iq0i4RciWV6z+lQHqDKtaVGgMsHn6PoeYhjf5Al5SP+U3imTjF2aCca1iDB5JOccX04M NljvifXgcbJNnkMgrzmm1ZgJ1PLur/ADWPlnz45quOhHg1TfUCLfI/DzgG7Z6u+oy4siQuFr9QT0 MQIDAQABo4HWMIHTMAkGA1UdEwQCMAAwEQYJYIZIAYb4QgEBBAQDAgWgMAsGA1UdDwQEAwIF4DAs BglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFHw4 +LnuALyLA5Cgy7T5ZAX1WzKPMB8GA1UdIwQYMBaAFF3U3hpBZq40HB5VM7B44/gmXiI0MDgGCWCG SAGG+EIBAwQrFilodHRwczovL2N1ZGFzeXN0ZW1zLm5ldDoxMTQ0My9yZXZva2VkLmNybDANBgkq hkiG9w0BAQUFAAOCAQEAZ0L4tQbBd0hd4wuw/YVqEBDDXJ54q2AoqQAmsOlnoxLO31ehM/LvrTIP 4yK2u1VmXtUumQ4Ao15JFM+xmwqtEGsh70RRrfVBAGd7KOZ3GB39FP2TgN/cL5fJKVxOqvEnW6cL 9QtvUlcM3hXg8kDv60OB+LIcSE/P3/s+0tEpWPjxm3LHVE7JmPbZIcJ1YMoZvHh0NSjY5D0HZlwt bDO7pDz9sZf1QEOgjH828fhtborkaHaUI46pmrMjiBnY6ujXMcWDpxtikki0zY22nrxfTs5xDWGx yrc/cmucjxClJF6+OYVUSaZhiiHfa9Pr+41okLgsRB0AmNwEf6ItY3TI8DGCBQowggUGAgEBMIGj MIGdMQswCQYDVQQGEwJVUzEQMA4GA1UECBMHRmxvcmlkYTESMBAGA1UEBxMJTmljZXZpbGxlMRkw FwYDVQQKExBDdWRhIFN5c3RlbXMgTExDMRwwGgYDVQQDExNDdWRhIFN5c3RlbXMgTExDIENBMS8w LQYJKoZIhvcNAQkBFiBjdXN0b21lci1zZXJ2aWNlQGN1ZGFzeXN0ZW1zLm5ldAIBCDAJBgUrDgMC GgUAoIICOzAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcBMBwGCSqGSIb3DQEJBTEPFw0xNDAzMjAx MjI2MzlaMCMGCSqGSIb3DQEJBDEWBBQR32SZybvYPRSh2yyMOKJNR5tQVDBsBgkqhkiG9w0BCQ8x XzBdMAsGCWCGSAFlAwQBKjALBglghkgBZQMEAQIwCgYIKoZIhvcNAwcwDgYIKoZIhvcNAwICAgCA MA0GCCqGSIb3DQMCAgFAMAcGBSsOAwIHMA0GCCqGSIb3DQMCAgEoMIG0BgkrBgEEAYI3EAQxgaYw gaMwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9yaWRhMRIwEAYDVQQHEwlOaWNldmlsbGUx GTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNVBAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0Ex LzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VAY3VkYXN5c3RlbXMubmV0AgEIMIG2Bgsq hkiG9w0BCRACCzGBpqCBozCBnTELMAkGA1UEBhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExEjAQBgNV BAcTCU5pY2V2aWxsZTEZMBcGA1UEChMQQ3VkYSBTeXN0ZW1zIExMQzEcMBoGA1UEAxMTQ3VkYSBT eXN0ZW1zIExMQyBDQTEvMC0GCSqGSIb3DQEJARYgY3VzdG9tZXItc2VydmljZUBjdWRhc3lzdGVt cy5uZXQCAQgwDQYJKoZIhvcNAQEBBQAEggIAjrvvzQFOgSuCeTX+6e+W/0jShDsUMgxPnQc3xi00 2hY/qcA5mOQCAa/Dyynmcsyp1vYz27QaI7Bs9wiH+m+0U5x7gdp5H6mICMKeUGVkvDCQ/z2+sORu F+LilHmq6D/vy7i44s47wQ8WXCk6/a9TJXF6v83f1oxJuxqwUm13Sny8xP/UQQXZZl/fv99j3B6j jiZZ9JfiTmhWDhb7e8OAFmgT68XAV5PHAYwvgSpaFxB3w/JCoolWscVL4n/ESFP26j3RxCYb4Zr0 jidpX+aeBdzCtx5BJE4OBHcTM6tH011jbtCdiRe5ruhtZq0gj0//egwZgyOUTFMWGF4j3XB7qeC8 pdv/W9PgdWUncn99kkgFfvi+QxtEe8EiKRc61VXSdt9REwtNKrHbmvCkPNWlCQ78lw5j3lfSG6bw Ybvwjc31/ZOlJ7kjEED4vvB70GSaFxeQTpGbMQwBkz5MpFlalj/w8XLy5AWcgENbs9VC4lVeqH78 vgg9oVJznlHipQO2emnGWFpsReX3vK65gaTM4i7a++zFX5uw/UabVTKdUvMyshX2pr++jeI2hK6h 8FHqd8PVK/nhNYaOQVD+e/1ju8v6YJWu4hQJDd44EleGDNXsEfm/FaZt6VNOZ+UZhvpfBdQaE+sE +DcTOhu/7eWIaiccO+s8tUFc+OCICTp2VFQAAAAAAAA= 140886 2014-03-20 17:00:54 +0000 2014-08-24 09:05:40 +0000 smime.p7s smime.p7s application/pkcs7-signature 2711 karl MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIIFTzCCBUsw ggQzoAMCAQICAQgwDQYJKoZIhvcNAQEFBQAwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9y aWRhMRIwEAYDVQQHEwlOaWNldmlsbGUxGTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNV BAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0ExLzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VA Y3VkYXN5c3RlbXMubmV0MB4XDTEzMDgyNDE5MDM0NFoXDTE4MDgyMzE5MDM0NFowWzELMAkGA1UE BhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExFzAVBgNVBAMTDkthcmwgRGVubmluZ2VyMSEwHwYJKoZI hvcNAQkBFhJrYXJsQGRlbm5pbmdlci5uZXQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC AQC5n2KBrBmG22nVntVdvgKCB9UcnapNThrW1L+dq6thd9l4mj+qYMUpJ+8I0rTbY1dn21IXQBoB Qmy8t1doKwmTdQ59F0FwZEPt/fGbRgBKVt3Quf6W6n7kRk9MG6gdD7V9vPpFV41e+5MWYtqGWY3S cDP8SyYLjL/Xgr+5KFKkDfuubK8DeNqdLniVjHo/vqmIgO+6NgzPGPgmbutzFQXlxUqjiNAAKzF2 +Tkddi+WKABrcc/EqnBb0X8GdqcIamO5SyVmuM+7Zdns7D9pcV16zMMQ8LfNFQCDvbCuuQKMDg2F 22x5ekYXpwjqTyfjcHBkWC8vFNoY5aFMdyiN/Kkz0/kduP2ekYOgkRqcShfLEcG9SQ4LQZgqjMpT jSOGzBr3tOvVn5LkSJSHW2Z8Q0dxSkvFG2/lsOWFbwQeeZSaBi5vRZCYCOf5tRd1+E93FyQfpt4v srXshIAk7IK7f0qXvxP4GDli5PKIEubD2Bn+gp3vB/DkfKySh5NBHVB+OPCoXRUWBkQxme65wBO0 2OZZt0k8Iq0i4RciWV6z+lQHqDKtaVGgMsHn6PoeYhjf5Al5SP+U3imTjF2aCca1iDB5JOccX04M NljvifXgcbJNnkMgrzmm1ZgJ1PLur/ADWPlnz45quOhHg1TfUCLfI/DzgG7Z6u+oy4siQuFr9QT0 MQIDAQABo4HWMIHTMAkGA1UdEwQCMAAwEQYJYIZIAYb4QgEBBAQDAgWgMAsGA1UdDwQEAwIF4DAs BglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFHw4 +LnuALyLA5Cgy7T5ZAX1WzKPMB8GA1UdIwQYMBaAFF3U3hpBZq40HB5VM7B44/gmXiI0MDgGCWCG SAGG+EIBAwQrFilodHRwczovL2N1ZGFzeXN0ZW1zLm5ldDoxMTQ0My9yZXZva2VkLmNybDANBgkq hkiG9w0BAQUFAAOCAQEAZ0L4tQbBd0hd4wuw/YVqEBDDXJ54q2AoqQAmsOlnoxLO31ehM/LvrTIP 4yK2u1VmXtUumQ4Ao15JFM+xmwqtEGsh70RRrfVBAGd7KOZ3GB39FP2TgN/cL5fJKVxOqvEnW6cL 9QtvUlcM3hXg8kDv60OB+LIcSE/P3/s+0tEpWPjxm3LHVE7JmPbZIcJ1YMoZvHh0NSjY5D0HZlwt bDO7pDz9sZf1QEOgjH828fhtborkaHaUI46pmrMjiBnY6ujXMcWDpxtikki0zY22nrxfTs5xDWGx yrc/cmucjxClJF6+OYVUSaZhiiHfa9Pr+41okLgsRB0AmNwEf6ItY3TI8DGCBQowggUGAgEBMIGj MIGdMQswCQYDVQQGEwJVUzEQMA4GA1UECBMHRmxvcmlkYTESMBAGA1UEBxMJTmljZXZpbGxlMRkw FwYDVQQKExBDdWRhIFN5c3RlbXMgTExDMRwwGgYDVQQDExNDdWRhIFN5c3RlbXMgTExDIENBMS8w LQYJKoZIhvcNAQkBFiBjdXN0b21lci1zZXJ2aWNlQGN1ZGFzeXN0ZW1zLm5ldAIBCDAJBgUrDgMC GgUAoIICOzAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcBMBwGCSqGSIb3DQEJBTEPFw0xNDAzMjAx NzAwNTRaMCMGCSqGSIb3DQEJBDEWBBQrRNHcjN1dwAlZu7blrh+3Vu7++TBsBgkqhkiG9w0BCQ8x XzBdMAsGCWCGSAFlAwQBKjALBglghkgBZQMEAQIwCgYIKoZIhvcNAwcwDgYIKoZIhvcNAwICAgCA MA0GCCqGSIb3DQMCAgFAMAcGBSsOAwIHMA0GCCqGSIb3DQMCAgEoMIG0BgkrBgEEAYI3EAQxgaYw gaMwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9yaWRhMRIwEAYDVQQHEwlOaWNldmlsbGUx GTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNVBAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0Ex LzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VAY3VkYXN5c3RlbXMubmV0AgEIMIG2Bgsq hkiG9w0BCRACCzGBpqCBozCBnTELMAkGA1UEBhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExEjAQBgNV BAcTCU5pY2V2aWxsZTEZMBcGA1UEChMQQ3VkYSBTeXN0ZW1zIExMQzEcMBoGA1UEAxMTQ3VkYSBT eXN0ZW1zIExMQyBDQTEvMC0GCSqGSIb3DQEJARYgY3VzdG9tZXItc2VydmljZUBjdWRhc3lzdGVt cy5uZXQCAQgwDQYJKoZIhvcNAQEBBQAEggIAsIbg6OIk2XnrPw25FA9+s4FCnKloWz3KtfA59Gf2 jX8yKEQW26k1QK6w62Zc8KaB5LypaOK1rZ5bipeu6rGHhgaG1oPXUMmcc2p4E18URDskAfn5apoJ /n54nR94OqHfQ/EPBx711pxYtAGBLFOOzwrU2MEZCl2KBydI+Bw/E75RWRIk6y0NqSWjgVWU2tJw nOEZj/2UGQCSvJ7h5t1n7idbDIfT88/hvAW3b3knRwPxwpZretXq2BGgmv8lojr7Zui5sR/YdDjS K2yGHqo0mWkSAHp0Wts8okcoJNZSEispFRh56MWCIoJ51ckipCZH/vX1EEsfka3CrlE7LWABAYf1 biy+Xq/Bfxgq9oAaknGF2yM0jgR7xnjLYLvbv5pjt7arTH2JslJMYkJPKiYFJNEgVJ9wTVQtrCPJ QPTk3R1qD3YFraly5Mgjwy5Ax5n8SW858WWOxHePvmL0j1boO0Re9qeAb9v/z8z3NPkFPZhBrEz3 g6INCWil+2Vx1yruJvxm1oN9OMQSt2qY38rjXWhWVxoQtW39LZc/xSNR41DQXvPJ8VOvyrmvLm7u Tm4+lQYVUwNuLNbDFlj8slkAeXF/eR1S4VuWtwexxCco+xGjbPTcZgap976XsvlRWOmjmwqZyGNu W7ZmcODQPFjQvpnBkx9Rm5cLndK6OVorTQkAAAAAAAA= 140887 2014-03-24 11:41:16 +0000 2014-08-24 09:05:40 +0000 smime.p7s smime.p7s application/pkcs7-signature 2711 karl MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIIFTzCCBUsw ggQzoAMCAQICAQgwDQYJKoZIhvcNAQEFBQAwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9y aWRhMRIwEAYDVQQHEwlOaWNldmlsbGUxGTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNV BAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0ExLzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VA Y3VkYXN5c3RlbXMubmV0MB4XDTEzMDgyNDE5MDM0NFoXDTE4MDgyMzE5MDM0NFowWzELMAkGA1UE BhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExFzAVBgNVBAMTDkthcmwgRGVubmluZ2VyMSEwHwYJKoZI hvcNAQkBFhJrYXJsQGRlbm5pbmdlci5uZXQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC AQC5n2KBrBmG22nVntVdvgKCB9UcnapNThrW1L+dq6thd9l4mj+qYMUpJ+8I0rTbY1dn21IXQBoB Qmy8t1doKwmTdQ59F0FwZEPt/fGbRgBKVt3Quf6W6n7kRk9MG6gdD7V9vPpFV41e+5MWYtqGWY3S cDP8SyYLjL/Xgr+5KFKkDfuubK8DeNqdLniVjHo/vqmIgO+6NgzPGPgmbutzFQXlxUqjiNAAKzF2 +Tkddi+WKABrcc/EqnBb0X8GdqcIamO5SyVmuM+7Zdns7D9pcV16zMMQ8LfNFQCDvbCuuQKMDg2F 22x5ekYXpwjqTyfjcHBkWC8vFNoY5aFMdyiN/Kkz0/kduP2ekYOgkRqcShfLEcG9SQ4LQZgqjMpT jSOGzBr3tOvVn5LkSJSHW2Z8Q0dxSkvFG2/lsOWFbwQeeZSaBi5vRZCYCOf5tRd1+E93FyQfpt4v srXshIAk7IK7f0qXvxP4GDli5PKIEubD2Bn+gp3vB/DkfKySh5NBHVB+OPCoXRUWBkQxme65wBO0 2OZZt0k8Iq0i4RciWV6z+lQHqDKtaVGgMsHn6PoeYhjf5Al5SP+U3imTjF2aCca1iDB5JOccX04M NljvifXgcbJNnkMgrzmm1ZgJ1PLur/ADWPlnz45quOhHg1TfUCLfI/DzgG7Z6u+oy4siQuFr9QT0 MQIDAQABo4HWMIHTMAkGA1UdEwQCMAAwEQYJYIZIAYb4QgEBBAQDAgWgMAsGA1UdDwQEAwIF4DAs BglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFHw4 +LnuALyLA5Cgy7T5ZAX1WzKPMB8GA1UdIwQYMBaAFF3U3hpBZq40HB5VM7B44/gmXiI0MDgGCWCG SAGG+EIBAwQrFilodHRwczovL2N1ZGFzeXN0ZW1zLm5ldDoxMTQ0My9yZXZva2VkLmNybDANBgkq hkiG9w0BAQUFAAOCAQEAZ0L4tQbBd0hd4wuw/YVqEBDDXJ54q2AoqQAmsOlnoxLO31ehM/LvrTIP 4yK2u1VmXtUumQ4Ao15JFM+xmwqtEGsh70RRrfVBAGd7KOZ3GB39FP2TgN/cL5fJKVxOqvEnW6cL 9QtvUlcM3hXg8kDv60OB+LIcSE/P3/s+0tEpWPjxm3LHVE7JmPbZIcJ1YMoZvHh0NSjY5D0HZlwt bDO7pDz9sZf1QEOgjH828fhtborkaHaUI46pmrMjiBnY6ujXMcWDpxtikki0zY22nrxfTs5xDWGx yrc/cmucjxClJF6+OYVUSaZhiiHfa9Pr+41okLgsRB0AmNwEf6ItY3TI8DGCBQowggUGAgEBMIGj MIGdMQswCQYDVQQGEwJVUzEQMA4GA1UECBMHRmxvcmlkYTESMBAGA1UEBxMJTmljZXZpbGxlMRkw FwYDVQQKExBDdWRhIFN5c3RlbXMgTExDMRwwGgYDVQQDExNDdWRhIFN5c3RlbXMgTExDIENBMS8w LQYJKoZIhvcNAQkBFiBjdXN0b21lci1zZXJ2aWNlQGN1ZGFzeXN0ZW1zLm5ldAIBCDAJBgUrDgMC GgUAoIICOzAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcBMBwGCSqGSIb3DQEJBTEPFw0xNDAzMjQx MTQxMTZaMCMGCSqGSIb3DQEJBDEWBBSpjQAUz/irMw8ktf83fseTJbi4szBsBgkqhkiG9w0BCQ8x XzBdMAsGCWCGSAFlAwQBKjALBglghkgBZQMEAQIwCgYIKoZIhvcNAwcwDgYIKoZIhvcNAwICAgCA MA0GCCqGSIb3DQMCAgFAMAcGBSsOAwIHMA0GCCqGSIb3DQMCAgEoMIG0BgkrBgEEAYI3EAQxgaYw gaMwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9yaWRhMRIwEAYDVQQHEwlOaWNldmlsbGUx GTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNVBAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0Ex LzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VAY3VkYXN5c3RlbXMubmV0AgEIMIG2Bgsq hkiG9w0BCRACCzGBpqCBozCBnTELMAkGA1UEBhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExEjAQBgNV BAcTCU5pY2V2aWxsZTEZMBcGA1UEChMQQ3VkYSBTeXN0ZW1zIExMQzEcMBoGA1UEAxMTQ3VkYSBT eXN0ZW1zIExMQyBDQTEvMC0GCSqGSIb3DQEJARYgY3VzdG9tZXItc2VydmljZUBjdWRhc3lzdGVt cy5uZXQCAQgwDQYJKoZIhvcNAQEBBQAEggIAgRTUPXy9Gqe69794f6zBeOsb1GYtt732rinQP9a/ SadpluwziBBHL2O1NpjuaP/TPTCQIj0Tc7T02QJ8KPmsLVpRy9r115eLcQ8LYp/jDpRwUXKn7690 gNf4NknaqmQTkiT7GN8/knSyyj3Oy3rWaTbjoAYsG5Iiu2aPiNP86SvZ60meUP6agmELnPRfpeJu ixzB225n7o8X20wkiG1iJYSLHDceuPo4oy6/OStg+efxcxxOrBrqPIMTn5pXK0iNKLxgyHWm3We3 jLXDq4NLBL844LJ1tuj1Axp++rwwhgs7aNHvwSwFc1iDh+KBUjxL0HTC5sapGdcyEFLcOW/SL400 sZOlxBjmHYCHQ/2toNiUdc9CsOiDmgMrkFjOvHrWqsuXwHFra919HLtiqdUy3TxYLDh+3toa/1BW /DEEYDtWPqjWcoHIp2RasLAeJl9HAqlU/KgqfrUaeM0mnAEVa0qx5/KaGFqN1sl9EYhIJJgVTsQp b2Xk84p4c2ANxoK2uZ912pNHcq7tiplVd0F+WuYrYVkaXh+QJARJo3+GPzc9UnErDHLQSMYLBVQz huA7CRDo/Orb2kUubZxWsD+9ztL/A8WdElW4DDD/or1xFdCsFPllvxFdiwBGKLccyqyPHQzgVQS+ Sgi0vL3Ph7RgKGkUf+qGJxBRs97sg58oRFcAAAAAAAA= 140888 2014-03-26 12:20:25 +0000 2014-08-24 09:05:40 +0000 smime.p7s smime.p7s application/pkcs7-signature 2711 karl MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIIFTzCCBUsw ggQzoAMCAQICAQgwDQYJKoZIhvcNAQEFBQAwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9y aWRhMRIwEAYDVQQHEwlOaWNldmlsbGUxGTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNV BAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0ExLzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VA Y3VkYXN5c3RlbXMubmV0MB4XDTEzMDgyNDE5MDM0NFoXDTE4MDgyMzE5MDM0NFowWzELMAkGA1UE BhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExFzAVBgNVBAMTDkthcmwgRGVubmluZ2VyMSEwHwYJKoZI hvcNAQkBFhJrYXJsQGRlbm5pbmdlci5uZXQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC AQC5n2KBrBmG22nVntVdvgKCB9UcnapNThrW1L+dq6thd9l4mj+qYMUpJ+8I0rTbY1dn21IXQBoB Qmy8t1doKwmTdQ59F0FwZEPt/fGbRgBKVt3Quf6W6n7kRk9MG6gdD7V9vPpFV41e+5MWYtqGWY3S cDP8SyYLjL/Xgr+5KFKkDfuubK8DeNqdLniVjHo/vqmIgO+6NgzPGPgmbutzFQXlxUqjiNAAKzF2 +Tkddi+WKABrcc/EqnBb0X8GdqcIamO5SyVmuM+7Zdns7D9pcV16zMMQ8LfNFQCDvbCuuQKMDg2F 22x5ekYXpwjqTyfjcHBkWC8vFNoY5aFMdyiN/Kkz0/kduP2ekYOgkRqcShfLEcG9SQ4LQZgqjMpT jSOGzBr3tOvVn5LkSJSHW2Z8Q0dxSkvFG2/lsOWFbwQeeZSaBi5vRZCYCOf5tRd1+E93FyQfpt4v srXshIAk7IK7f0qXvxP4GDli5PKIEubD2Bn+gp3vB/DkfKySh5NBHVB+OPCoXRUWBkQxme65wBO0 2OZZt0k8Iq0i4RciWV6z+lQHqDKtaVGgMsHn6PoeYhjf5Al5SP+U3imTjF2aCca1iDB5JOccX04M NljvifXgcbJNnkMgrzmm1ZgJ1PLur/ADWPlnz45quOhHg1TfUCLfI/DzgG7Z6u+oy4siQuFr9QT0 MQIDAQABo4HWMIHTMAkGA1UdEwQCMAAwEQYJYIZIAYb4QgEBBAQDAgWgMAsGA1UdDwQEAwIF4DAs BglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFHw4 +LnuALyLA5Cgy7T5ZAX1WzKPMB8GA1UdIwQYMBaAFF3U3hpBZq40HB5VM7B44/gmXiI0MDgGCWCG SAGG+EIBAwQrFilodHRwczovL2N1ZGFzeXN0ZW1zLm5ldDoxMTQ0My9yZXZva2VkLmNybDANBgkq hkiG9w0BAQUFAAOCAQEAZ0L4tQbBd0hd4wuw/YVqEBDDXJ54q2AoqQAmsOlnoxLO31ehM/LvrTIP 4yK2u1VmXtUumQ4Ao15JFM+xmwqtEGsh70RRrfVBAGd7KOZ3GB39FP2TgN/cL5fJKVxOqvEnW6cL 9QtvUlcM3hXg8kDv60OB+LIcSE/P3/s+0tEpWPjxm3LHVE7JmPbZIcJ1YMoZvHh0NSjY5D0HZlwt bDO7pDz9sZf1QEOgjH828fhtborkaHaUI46pmrMjiBnY6ujXMcWDpxtikki0zY22nrxfTs5xDWGx yrc/cmucjxClJF6+OYVUSaZhiiHfa9Pr+41okLgsRB0AmNwEf6ItY3TI8DGCBQowggUGAgEBMIGj MIGdMQswCQYDVQQGEwJVUzEQMA4GA1UECBMHRmxvcmlkYTESMBAGA1UEBxMJTmljZXZpbGxlMRkw FwYDVQQKExBDdWRhIFN5c3RlbXMgTExDMRwwGgYDVQQDExNDdWRhIFN5c3RlbXMgTExDIENBMS8w LQYJKoZIhvcNAQkBFiBjdXN0b21lci1zZXJ2aWNlQGN1ZGFzeXN0ZW1zLm5ldAIBCDAJBgUrDgMC GgUAoIICOzAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcBMBwGCSqGSIb3DQEJBTEPFw0xNDAzMjYx MjIwMjVaMCMGCSqGSIb3DQEJBDEWBBSDwhwrsF5DQBRdl4eHVgPE1IGT8TBsBgkqhkiG9w0BCQ8x XzBdMAsGCWCGSAFlAwQBKjALBglghkgBZQMEAQIwCgYIKoZIhvcNAwcwDgYIKoZIhvcNAwICAgCA MA0GCCqGSIb3DQMCAgFAMAcGBSsOAwIHMA0GCCqGSIb3DQMCAgEoMIG0BgkrBgEEAYI3EAQxgaYw gaMwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9yaWRhMRIwEAYDVQQHEwlOaWNldmlsbGUx GTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNVBAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0Ex LzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VAY3VkYXN5c3RlbXMubmV0AgEIMIG2Bgsq hkiG9w0BCRACCzGBpqCBozCBnTELMAkGA1UEBhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExEjAQBgNV BAcTCU5pY2V2aWxsZTEZMBcGA1UEChMQQ3VkYSBTeXN0ZW1zIExMQzEcMBoGA1UEAxMTQ3VkYSBT eXN0ZW1zIExMQyBDQTEvMC0GCSqGSIb3DQEJARYgY3VzdG9tZXItc2VydmljZUBjdWRhc3lzdGVt cy5uZXQCAQgwDQYJKoZIhvcNAQEBBQAEggIAYDUFBvfbzEjGO/S9bOndOoWVjRmco2r5uLDYcA5L cy04X65DZX0UdMRdhRpRjaKfTESjoGnxv6nLif1h3jA2K27oSNBZGCOStD62V+z7xj7k1Q1UDPwM IDHqKFhd6UCM5C6zFj8mLOeBMqKRzPIGZ98f8MN5/0zoQWLlJgXuvpFbO1LXUvaiY/2Y1nmFoKTp cF5Yql3pazCTz+O9usLPLKblRZn3INyxBhgcvP1tgZfJinr4nt9NKRC9//tuTpdFlzcqXBgkB/py p5i+zUXqQp7cyKxk8DO2lJ54QJs6VMzkv/GV1Buo/fo4p0jbKw4axJnB22LRpkV8b+O4hLB9yDAh sfBocQ1kY5d38wawzXgXxJxcLQjSvC0mECoXs1wY1lSrla0VQdjLCiBzX62uFSGr/WY/RDHgkgFn AHHy2qAgrvX/Uiw9zaxrXnUpte4fMhokAdwYFOY57+XLtq+xawHfwrWanemu677V2ZC7e+UatDNZ y7BjzRKq5vNg2OvlXNskE8WQJGgE7DSi2+cz8n905Ou66/EcARS20VHGjb+KA70f/BDO3Q7a5WOz UxxyUb4s95wnVV7ty9Vh8VuMxLSdE1wYoy7xGTxEHRffkqUSTG2r4zvoygsRnglRKXZjJs2AIMSu EwtzFgGM3nwF06I4NelJf0zkjrfyKOEtrekAAAAAAAA= 140889 2014-03-28 01:32:17 +0000 2014-08-24 09:05:40 +0000 smime.p7s smime.p7s application/pkcs7-signature 2711 karl MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIIFTzCCBUsw ggQzoAMCAQICAQgwDQYJKoZIhvcNAQEFBQAwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9y aWRhMRIwEAYDVQQHEwlOaWNldmlsbGUxGTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNV BAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0ExLzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VA Y3VkYXN5c3RlbXMubmV0MB4XDTEzMDgyNDE5MDM0NFoXDTE4MDgyMzE5MDM0NFowWzELMAkGA1UE BhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExFzAVBgNVBAMTDkthcmwgRGVubmluZ2VyMSEwHwYJKoZI hvcNAQkBFhJrYXJsQGRlbm5pbmdlci5uZXQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC AQC5n2KBrBmG22nVntVdvgKCB9UcnapNThrW1L+dq6thd9l4mj+qYMUpJ+8I0rTbY1dn21IXQBoB Qmy8t1doKwmTdQ59F0FwZEPt/fGbRgBKVt3Quf6W6n7kRk9MG6gdD7V9vPpFV41e+5MWYtqGWY3S cDP8SyYLjL/Xgr+5KFKkDfuubK8DeNqdLniVjHo/vqmIgO+6NgzPGPgmbutzFQXlxUqjiNAAKzF2 +Tkddi+WKABrcc/EqnBb0X8GdqcIamO5SyVmuM+7Zdns7D9pcV16zMMQ8LfNFQCDvbCuuQKMDg2F 22x5ekYXpwjqTyfjcHBkWC8vFNoY5aFMdyiN/Kkz0/kduP2ekYOgkRqcShfLEcG9SQ4LQZgqjMpT jSOGzBr3tOvVn5LkSJSHW2Z8Q0dxSkvFG2/lsOWFbwQeeZSaBi5vRZCYCOf5tRd1+E93FyQfpt4v srXshIAk7IK7f0qXvxP4GDli5PKIEubD2Bn+gp3vB/DkfKySh5NBHVB+OPCoXRUWBkQxme65wBO0 2OZZt0k8Iq0i4RciWV6z+lQHqDKtaVGgMsHn6PoeYhjf5Al5SP+U3imTjF2aCca1iDB5JOccX04M NljvifXgcbJNnkMgrzmm1ZgJ1PLur/ADWPlnz45quOhHg1TfUCLfI/DzgG7Z6u+oy4siQuFr9QT0 MQIDAQABo4HWMIHTMAkGA1UdEwQCMAAwEQYJYIZIAYb4QgEBBAQDAgWgMAsGA1UdDwQEAwIF4DAs BglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFHw4 +LnuALyLA5Cgy7T5ZAX1WzKPMB8GA1UdIwQYMBaAFF3U3hpBZq40HB5VM7B44/gmXiI0MDgGCWCG SAGG+EIBAwQrFilodHRwczovL2N1ZGFzeXN0ZW1zLm5ldDoxMTQ0My9yZXZva2VkLmNybDANBgkq hkiG9w0BAQUFAAOCAQEAZ0L4tQbBd0hd4wuw/YVqEBDDXJ54q2AoqQAmsOlnoxLO31ehM/LvrTIP 4yK2u1VmXtUumQ4Ao15JFM+xmwqtEGsh70RRrfVBAGd7KOZ3GB39FP2TgN/cL5fJKVxOqvEnW6cL 9QtvUlcM3hXg8kDv60OB+LIcSE/P3/s+0tEpWPjxm3LHVE7JmPbZIcJ1YMoZvHh0NSjY5D0HZlwt bDO7pDz9sZf1QEOgjH828fhtborkaHaUI46pmrMjiBnY6ujXMcWDpxtikki0zY22nrxfTs5xDWGx yrc/cmucjxClJF6+OYVUSaZhiiHfa9Pr+41okLgsRB0AmNwEf6ItY3TI8DGCBQowggUGAgEBMIGj MIGdMQswCQYDVQQGEwJVUzEQMA4GA1UECBMHRmxvcmlkYTESMBAGA1UEBxMJTmljZXZpbGxlMRkw FwYDVQQKExBDdWRhIFN5c3RlbXMgTExDMRwwGgYDVQQDExNDdWRhIFN5c3RlbXMgTExDIENBMS8w LQYJKoZIhvcNAQkBFiBjdXN0b21lci1zZXJ2aWNlQGN1ZGFzeXN0ZW1zLm5ldAIBCDAJBgUrDgMC GgUAoIICOzAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcBMBwGCSqGSIb3DQEJBTEPFw0xNDAzMjgw MTMyMTdaMCMGCSqGSIb3DQEJBDEWBBSHn3P56J5+zff1Vf53Qobt/cgTwjBsBgkqhkiG9w0BCQ8x XzBdMAsGCWCGSAFlAwQBKjALBglghkgBZQMEAQIwCgYIKoZIhvcNAwcwDgYIKoZIhvcNAwICAgCA MA0GCCqGSIb3DQMCAgFAMAcGBSsOAwIHMA0GCCqGSIb3DQMCAgEoMIG0BgkrBgEEAYI3EAQxgaYw gaMwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9yaWRhMRIwEAYDVQQHEwlOaWNldmlsbGUx GTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNVBAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0Ex LzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VAY3VkYXN5c3RlbXMubmV0AgEIMIG2Bgsq hkiG9w0BCRACCzGBpqCBozCBnTELMAkGA1UEBhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExEjAQBgNV BAcTCU5pY2V2aWxsZTEZMBcGA1UEChMQQ3VkYSBTeXN0ZW1zIExMQzEcMBoGA1UEAxMTQ3VkYSBT eXN0ZW1zIExMQyBDQTEvMC0GCSqGSIb3DQEJARYgY3VzdG9tZXItc2VydmljZUBjdWRhc3lzdGVt cy5uZXQCAQgwDQYJKoZIhvcNAQEBBQAEggIABDSkqEfzqvQZihKsBol+YJIFn5MBeum5+9zmYaDC SWT2QCYTYmC1oe7/YORhWUAm/9/W0kHqTzh5vQQyF8RUKoNFGOgLWAYHbv6NGoKPh65jqJK7FMbx YtX/wakEaV+wsRTBBbWRdy6PjBtPhwy0izxRVzKk+SfgQkPB6E6Kzv/O8BflxmuxA2cECq9rHsPQ y9xDmRhLHUTDy8g155NQ5YWNbx7LORTQF072Z0woI7cQPTgW3NrVyNvtFckQ6Lc6z91j7bsB0VfQ vAYMTRpOm0oesUKLYRrZSo+vMuATrC9AC7Ehzcx2fglMMwszxywZ5jzvn+3Hh61aphhC6XqT513h WjhgeV7yH2TH3aMeGdzjF0JQnDWz90KmiWsSO4mb8zFcDevvir/rgGddETsPyE1jDfBGxHiVJjIw VSI/9/6AKiuc2VULrDnz6rDM2QinZ4nlZGslL07e3vfxZMoSPGOQaljKOLEJrQ3lLS4ax8L3ised vW1X2Akg8G9zMLrzNy9YVESE8xTZEVCpPHqfgb6hjL4Zs5xZ+iAIXJv4fz4xS+OLQgpE05JBqbV9 SvTu+Dp+iKzQsa5hkXkwy6/OXa/mumfq4dl5muWQGUs6xjKBj+0fmnuX5BRE4+weWOei2DR/sRLW EmRllJFpuR9qhQ6rMBc/53/Wy01N6qD7zncAAAAAAAA= 140890 2014-04-03 17:57:50 +0000 2014-08-24 09:05:40 +0000 smime.p7s smime.p7s application/pkcs7-signature 2711 karl MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIIFTzCCBUsw ggQzoAMCAQICAQgwDQYJKoZIhvcNAQEFBQAwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9y aWRhMRIwEAYDVQQHEwlOaWNldmlsbGUxGTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNV BAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0ExLzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VA Y3VkYXN5c3RlbXMubmV0MB4XDTEzMDgyNDE5MDM0NFoXDTE4MDgyMzE5MDM0NFowWzELMAkGA1UE BhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExFzAVBgNVBAMTDkthcmwgRGVubmluZ2VyMSEwHwYJKoZI hvcNAQkBFhJrYXJsQGRlbm5pbmdlci5uZXQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC AQC5n2KBrBmG22nVntVdvgKCB9UcnapNThrW1L+dq6thd9l4mj+qYMUpJ+8I0rTbY1dn21IXQBoB Qmy8t1doKwmTdQ59F0FwZEPt/fGbRgBKVt3Quf6W6n7kRk9MG6gdD7V9vPpFV41e+5MWYtqGWY3S cDP8SyYLjL/Xgr+5KFKkDfuubK8DeNqdLniVjHo/vqmIgO+6NgzPGPgmbutzFQXlxUqjiNAAKzF2 +Tkddi+WKABrcc/EqnBb0X8GdqcIamO5SyVmuM+7Zdns7D9pcV16zMMQ8LfNFQCDvbCuuQKMDg2F 22x5ekYXpwjqTyfjcHBkWC8vFNoY5aFMdyiN/Kkz0/kduP2ekYOgkRqcShfLEcG9SQ4LQZgqjMpT jSOGzBr3tOvVn5LkSJSHW2Z8Q0dxSkvFG2/lsOWFbwQeeZSaBi5vRZCYCOf5tRd1+E93FyQfpt4v srXshIAk7IK7f0qXvxP4GDli5PKIEubD2Bn+gp3vB/DkfKySh5NBHVB+OPCoXRUWBkQxme65wBO0 2OZZt0k8Iq0i4RciWV6z+lQHqDKtaVGgMsHn6PoeYhjf5Al5SP+U3imTjF2aCca1iDB5JOccX04M NljvifXgcbJNnkMgrzmm1ZgJ1PLur/ADWPlnz45quOhHg1TfUCLfI/DzgG7Z6u+oy4siQuFr9QT0 MQIDAQABo4HWMIHTMAkGA1UdEwQCMAAwEQYJYIZIAYb4QgEBBAQDAgWgMAsGA1UdDwQEAwIF4DAs BglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFHw4 +LnuALyLA5Cgy7T5ZAX1WzKPMB8GA1UdIwQYMBaAFF3U3hpBZq40HB5VM7B44/gmXiI0MDgGCWCG SAGG+EIBAwQrFilodHRwczovL2N1ZGFzeXN0ZW1zLm5ldDoxMTQ0My9yZXZva2VkLmNybDANBgkq hkiG9w0BAQUFAAOCAQEAZ0L4tQbBd0hd4wuw/YVqEBDDXJ54q2AoqQAmsOlnoxLO31ehM/LvrTIP 4yK2u1VmXtUumQ4Ao15JFM+xmwqtEGsh70RRrfVBAGd7KOZ3GB39FP2TgN/cL5fJKVxOqvEnW6cL 9QtvUlcM3hXg8kDv60OB+LIcSE/P3/s+0tEpWPjxm3LHVE7JmPbZIcJ1YMoZvHh0NSjY5D0HZlwt bDO7pDz9sZf1QEOgjH828fhtborkaHaUI46pmrMjiBnY6ujXMcWDpxtikki0zY22nrxfTs5xDWGx yrc/cmucjxClJF6+OYVUSaZhiiHfa9Pr+41okLgsRB0AmNwEf6ItY3TI8DGCBQowggUGAgEBMIGj MIGdMQswCQYDVQQGEwJVUzEQMA4GA1UECBMHRmxvcmlkYTESMBAGA1UEBxMJTmljZXZpbGxlMRkw FwYDVQQKExBDdWRhIFN5c3RlbXMgTExDMRwwGgYDVQQDExNDdWRhIFN5c3RlbXMgTExDIENBMS8w LQYJKoZIhvcNAQkBFiBjdXN0b21lci1zZXJ2aWNlQGN1ZGFzeXN0ZW1zLm5ldAIBCDAJBgUrDgMC GgUAoIICOzAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcBMBwGCSqGSIb3DQEJBTEPFw0xNDA0MDMx NjU3NTBaMCMGCSqGSIb3DQEJBDEWBBQtiQvKlj5Ru9Pv6YxPqFzRIx08NDBsBgkqhkiG9w0BCQ8x XzBdMAsGCWCGSAFlAwQBKjALBglghkgBZQMEAQIwCgYIKoZIhvcNAwcwDgYIKoZIhvcNAwICAgCA MA0GCCqGSIb3DQMCAgFAMAcGBSsOAwIHMA0GCCqGSIb3DQMCAgEoMIG0BgkrBgEEAYI3EAQxgaYw gaMwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9yaWRhMRIwEAYDVQQHEwlOaWNldmlsbGUx GTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNVBAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0Ex LzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VAY3VkYXN5c3RlbXMubmV0AgEIMIG2Bgsq hkiG9w0BCRACCzGBpqCBozCBnTELMAkGA1UEBhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExEjAQBgNV BAcTCU5pY2V2aWxsZTEZMBcGA1UEChMQQ3VkYSBTeXN0ZW1zIExMQzEcMBoGA1UEAxMTQ3VkYSBT eXN0ZW1zIExMQyBDQTEvMC0GCSqGSIb3DQEJARYgY3VzdG9tZXItc2VydmljZUBjdWRhc3lzdGVt cy5uZXQCAQgwDQYJKoZIhvcNAQEBBQAEggIASySS2MCYfM+HpbvhybMFLOf39MPG9lKM9kaeWPUh LSzp5DqLZuL4cvQvel17Pr7SNed8aqtR+VoSQ3QyxDEdNRRh3jGA+Nk1GYdLUFaOPwxrmie0+IaM xjay5SoZoaBnuDL15QoExVIQIwindXtuX2R6ze97agYUn91exV/6GLhg51QuOancUKExT1zGOEMz Lg2YxpYQOb6yicsjaqXOTLHcUGh+oZRRzNelEpUCSAotnkOa7ikxjuNPdyfyJPZO4Oapvn0TwWY0 3JBX2BbhCRU5wLU7U0PPpExH/wbH1EpjXMT5Xx5g15EERk7N6E7nMROdEJmyK2N1pkD43paPX4oz 5pjwiZZSOzr8HrV/pxzUitv2zOvonpmwYIpFlub9XGk1MUn2NNCpttbhLRgMSFFa99gakenZEjq3 mrW4chJyHGg10FXh+Mrxh8Dv/HRB1sVRzp3D8LPw2nUw2MV9mhfZJGGz5QSkqudGwOkC7EMvHtdh EiyLWiHs6Ro9YWT65uGiz1uZcdhexGyjJjg8pSkcLaG++Ty+LtwJknhdwgHlDdDsThE1Zf8YXf10 BA96uykt53sLbwnW20yy5FpGr8dcgiWhH4a84Div8YZ0OnR3+MyOXMU0+EBet1ojAarc2xMH6m+M nqIMl6nL9BhiEA51KE84odL6Nw8zsNJgryAAAAAAAAA= 140891 2014-04-14 16:40:49 +0000 2014-08-24 09:05:40 +0000 smime.p7s smime.p7s application/pkcs7-signature 2711 karl MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIIFTzCCBUsw ggQzoAMCAQICAQgwDQYJKoZIhvcNAQEFBQAwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9y aWRhMRIwEAYDVQQHEwlOaWNldmlsbGUxGTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNV BAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0ExLzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VA Y3VkYXN5c3RlbXMubmV0MB4XDTEzMDgyNDE5MDM0NFoXDTE4MDgyMzE5MDM0NFowWzELMAkGA1UE BhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExFzAVBgNVBAMTDkthcmwgRGVubmluZ2VyMSEwHwYJKoZI hvcNAQkBFhJrYXJsQGRlbm5pbmdlci5uZXQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC AQC5n2KBrBmG22nVntVdvgKCB9UcnapNThrW1L+dq6thd9l4mj+qYMUpJ+8I0rTbY1dn21IXQBoB Qmy8t1doKwmTdQ59F0FwZEPt/fGbRgBKVt3Quf6W6n7kRk9MG6gdD7V9vPpFV41e+5MWYtqGWY3S cDP8SyYLjL/Xgr+5KFKkDfuubK8DeNqdLniVjHo/vqmIgO+6NgzPGPgmbutzFQXlxUqjiNAAKzF2 +Tkddi+WKABrcc/EqnBb0X8GdqcIamO5SyVmuM+7Zdns7D9pcV16zMMQ8LfNFQCDvbCuuQKMDg2F 22x5ekYXpwjqTyfjcHBkWC8vFNoY5aFMdyiN/Kkz0/kduP2ekYOgkRqcShfLEcG9SQ4LQZgqjMpT jSOGzBr3tOvVn5LkSJSHW2Z8Q0dxSkvFG2/lsOWFbwQeeZSaBi5vRZCYCOf5tRd1+E93FyQfpt4v srXshIAk7IK7f0qXvxP4GDli5PKIEubD2Bn+gp3vB/DkfKySh5NBHVB+OPCoXRUWBkQxme65wBO0 2OZZt0k8Iq0i4RciWV6z+lQHqDKtaVGgMsHn6PoeYhjf5Al5SP+U3imTjF2aCca1iDB5JOccX04M NljvifXgcbJNnkMgrzmm1ZgJ1PLur/ADWPlnz45quOhHg1TfUCLfI/DzgG7Z6u+oy4siQuFr9QT0 MQIDAQABo4HWMIHTMAkGA1UdEwQCMAAwEQYJYIZIAYb4QgEBBAQDAgWgMAsGA1UdDwQEAwIF4DAs BglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFHw4 +LnuALyLA5Cgy7T5ZAX1WzKPMB8GA1UdIwQYMBaAFF3U3hpBZq40HB5VM7B44/gmXiI0MDgGCWCG SAGG+EIBAwQrFilodHRwczovL2N1ZGFzeXN0ZW1zLm5ldDoxMTQ0My9yZXZva2VkLmNybDANBgkq hkiG9w0BAQUFAAOCAQEAZ0L4tQbBd0hd4wuw/YVqEBDDXJ54q2AoqQAmsOlnoxLO31ehM/LvrTIP 4yK2u1VmXtUumQ4Ao15JFM+xmwqtEGsh70RRrfVBAGd7KOZ3GB39FP2TgN/cL5fJKVxOqvEnW6cL 9QtvUlcM3hXg8kDv60OB+LIcSE/P3/s+0tEpWPjxm3LHVE7JmPbZIcJ1YMoZvHh0NSjY5D0HZlwt bDO7pDz9sZf1QEOgjH828fhtborkaHaUI46pmrMjiBnY6ujXMcWDpxtikki0zY22nrxfTs5xDWGx yrc/cmucjxClJF6+OYVUSaZhiiHfa9Pr+41okLgsRB0AmNwEf6ItY3TI8DGCBQowggUGAgEBMIGj MIGdMQswCQYDVQQGEwJVUzEQMA4GA1UECBMHRmxvcmlkYTESMBAGA1UEBxMJTmljZXZpbGxlMRkw FwYDVQQKExBDdWRhIFN5c3RlbXMgTExDMRwwGgYDVQQDExNDdWRhIFN5c3RlbXMgTExDIENBMS8w LQYJKoZIhvcNAQkBFiBjdXN0b21lci1zZXJ2aWNlQGN1ZGFzeXN0ZW1zLm5ldAIBCDAJBgUrDgMC GgUAoIICOzAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcBMBwGCSqGSIb3DQEJBTEPFw0xNDA0MTQx NTQwNDlaMCMGCSqGSIb3DQEJBDEWBBQYq2pvkbMCcqXmG1R35UciRZZfHTBsBgkqhkiG9w0BCQ8x XzBdMAsGCWCGSAFlAwQBKjALBglghkgBZQMEAQIwCgYIKoZIhvcNAwcwDgYIKoZIhvcNAwICAgCA MA0GCCqGSIb3DQMCAgFAMAcGBSsOAwIHMA0GCCqGSIb3DQMCAgEoMIG0BgkrBgEEAYI3EAQxgaYw gaMwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9yaWRhMRIwEAYDVQQHEwlOaWNldmlsbGUx GTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNVBAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0Ex LzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VAY3VkYXN5c3RlbXMubmV0AgEIMIG2Bgsq hkiG9w0BCRACCzGBpqCBozCBnTELMAkGA1UEBhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExEjAQBgNV BAcTCU5pY2V2aWxsZTEZMBcGA1UEChMQQ3VkYSBTeXN0ZW1zIExMQzEcMBoGA1UEAxMTQ3VkYSBT eXN0ZW1zIExMQyBDQTEvMC0GCSqGSIb3DQEJARYgY3VzdG9tZXItc2VydmljZUBjdWRhc3lzdGVt cy5uZXQCAQgwDQYJKoZIhvcNAQEBBQAEggIAXwyNfelEJ1dXzTY8t4nHykXZincjdfw/aVPIlXlU Pk87GtZCSj2t30EAGMt4+wjhwUre+ZGl/9A6DBnBJ6XHNpqSqY5kSGA19L7+beTSTC4/dUcLA8EP VNbMyYPN1SsY/uyz/AzSfTAra9Ypy+n9pEPE4dQPfCN9W3RmKAeiQ4uXW1mkFQNUcYoGy5pwROpY 2PT6ZUpWT8OM809PvhSI74pvepv95E0Gkl0kyg43MTO114A8jNPfXueHegfAvy5Prhb+VxKwWRZt D35toCepCy4q446nMGMVbyptKxcZ/HQj45ukCsCbQfRUP4yCichEitLOJ5LfO5jg+3aQKaSgz8By HLLXOCD0pZufXPkGiqM/Pd+bnZB/J4pwgHDMxnHjsOnfImrDJzRsZ6e90ym6SwvGeZ4Ta4zwivc+ y0WpnP2csN80gr128CB9yGqWOIOg2viB8PpY0hXhHnT0cdPZt2jw235qoYMzIRpbjDkAXIyGiIVN uf4ga5fELo/Z54GWYzvvXDI4PNQ42CTeNxcTdKfUgcqWyxIFczhF67apxw0xiM4XxPTMmaqV8Eht xizUpAEMvuatrInELjxyCkoD5ie2PZdhl+bw/MVLlcYMGO6i29XKfUdupAQIO6eAtmJB/lllH600 R/YcpTQia9nibgX3/wAAD76k+JEfIj7SLrkAAAAAAAA= 140892 2014-05-15 16:05:34 +0000 2014-08-24 09:05:40 +0000 smime.p7s smime.p7s application/pkcs7-signature 2711 karl MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIIFTzCCBUsw ggQzoAMCAQICAQgwDQYJKoZIhvcNAQEFBQAwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9y aWRhMRIwEAYDVQQHEwlOaWNldmlsbGUxGTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNV BAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0ExLzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VA Y3VkYXN5c3RlbXMubmV0MB4XDTEzMDgyNDE5MDM0NFoXDTE4MDgyMzE5MDM0NFowWzELMAkGA1UE BhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExFzAVBgNVBAMTDkthcmwgRGVubmluZ2VyMSEwHwYJKoZI hvcNAQkBFhJrYXJsQGRlbm5pbmdlci5uZXQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC AQC5n2KBrBmG22nVntVdvgKCB9UcnapNThrW1L+dq6thd9l4mj+qYMUpJ+8I0rTbY1dn21IXQBoB Qmy8t1doKwmTdQ59F0FwZEPt/fGbRgBKVt3Quf6W6n7kRk9MG6gdD7V9vPpFV41e+5MWYtqGWY3S cDP8SyYLjL/Xgr+5KFKkDfuubK8DeNqdLniVjHo/vqmIgO+6NgzPGPgmbutzFQXlxUqjiNAAKzF2 +Tkddi+WKABrcc/EqnBb0X8GdqcIamO5SyVmuM+7Zdns7D9pcV16zMMQ8LfNFQCDvbCuuQKMDg2F 22x5ekYXpwjqTyfjcHBkWC8vFNoY5aFMdyiN/Kkz0/kduP2ekYOgkRqcShfLEcG9SQ4LQZgqjMpT jSOGzBr3tOvVn5LkSJSHW2Z8Q0dxSkvFG2/lsOWFbwQeeZSaBi5vRZCYCOf5tRd1+E93FyQfpt4v srXshIAk7IK7f0qXvxP4GDli5PKIEubD2Bn+gp3vB/DkfKySh5NBHVB+OPCoXRUWBkQxme65wBO0 2OZZt0k8Iq0i4RciWV6z+lQHqDKtaVGgMsHn6PoeYhjf5Al5SP+U3imTjF2aCca1iDB5JOccX04M NljvifXgcbJNnkMgrzmm1ZgJ1PLur/ADWPlnz45quOhHg1TfUCLfI/DzgG7Z6u+oy4siQuFr9QT0 MQIDAQABo4HWMIHTMAkGA1UdEwQCMAAwEQYJYIZIAYb4QgEBBAQDAgWgMAsGA1UdDwQEAwIF4DAs BglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFHw4 +LnuALyLA5Cgy7T5ZAX1WzKPMB8GA1UdIwQYMBaAFF3U3hpBZq40HB5VM7B44/gmXiI0MDgGCWCG SAGG+EIBAwQrFilodHRwczovL2N1ZGFzeXN0ZW1zLm5ldDoxMTQ0My9yZXZva2VkLmNybDANBgkq hkiG9w0BAQUFAAOCAQEAZ0L4tQbBd0hd4wuw/YVqEBDDXJ54q2AoqQAmsOlnoxLO31ehM/LvrTIP 4yK2u1VmXtUumQ4Ao15JFM+xmwqtEGsh70RRrfVBAGd7KOZ3GB39FP2TgN/cL5fJKVxOqvEnW6cL 9QtvUlcM3hXg8kDv60OB+LIcSE/P3/s+0tEpWPjxm3LHVE7JmPbZIcJ1YMoZvHh0NSjY5D0HZlwt bDO7pDz9sZf1QEOgjH828fhtborkaHaUI46pmrMjiBnY6ujXMcWDpxtikki0zY22nrxfTs5xDWGx yrc/cmucjxClJF6+OYVUSaZhiiHfa9Pr+41okLgsRB0AmNwEf6ItY3TI8DGCBQowggUGAgEBMIGj MIGdMQswCQYDVQQGEwJVUzEQMA4GA1UECBMHRmxvcmlkYTESMBAGA1UEBxMJTmljZXZpbGxlMRkw FwYDVQQKExBDdWRhIFN5c3RlbXMgTExDMRwwGgYDVQQDExNDdWRhIFN5c3RlbXMgTExDIENBMS8w LQYJKoZIhvcNAQkBFiBjdXN0b21lci1zZXJ2aWNlQGN1ZGFzeXN0ZW1zLm5ldAIBCDAJBgUrDgMC GgUAoIICOzAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcBMBwGCSqGSIb3DQEJBTEPFw0xNDA1MTUx NTA1MzRaMCMGCSqGSIb3DQEJBDEWBBSbaVBm+ygF/PjHv+0foTPNgyAZHDBsBgkqhkiG9w0BCQ8x XzBdMAsGCWCGSAFlAwQBKjALBglghkgBZQMEAQIwCgYIKoZIhvcNAwcwDgYIKoZIhvcNAwICAgCA MA0GCCqGSIb3DQMCAgFAMAcGBSsOAwIHMA0GCCqGSIb3DQMCAgEoMIG0BgkrBgEEAYI3EAQxgaYw gaMwgZ0xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdGbG9yaWRhMRIwEAYDVQQHEwlOaWNldmlsbGUx GTAXBgNVBAoTEEN1ZGEgU3lzdGVtcyBMTEMxHDAaBgNVBAMTE0N1ZGEgU3lzdGVtcyBMTEMgQ0Ex LzAtBgkqhkiG9w0BCQEWIGN1c3RvbWVyLXNlcnZpY2VAY3VkYXN5c3RlbXMubmV0AgEIMIG2Bgsq hkiG9w0BCRACCzGBpqCBozCBnTELMAkGA1UEBhMCVVMxEDAOBgNVBAgTB0Zsb3JpZGExEjAQBgNV BAcTCU5pY2V2aWxsZTEZMBcGA1UEChMQQ3VkYSBTeXN0ZW1zIExMQzEcMBoGA1UEAxMTQ3VkYSBT eXN0ZW1zIExMQyBDQTEvMC0GCSqGSIb3DQEJARYgY3VzdG9tZXItc2VydmljZUBjdWRhc3lzdGVt cy5uZXQCAQgwDQYJKoZIhvcNAQEBBQAEggIADfjFv6rTjcQz+JkCtjZT46+zYdFweGsHTyUH/Upl ZMAEw0ZKjz23rJwI5tG/bZFXI3XKqQl1cENsPHLydVEqEz15Qj1k2QlD/FyMzYuy0ylyiH96jpPH Q68DznVTahj5Oiv24s7mZExPlDtzLtO8KtbdIEy75aT5PpP7Er+ZhVLL55cY4F+CMxcsU5SzmMYt mURF9is0SucxSFe1KOv+By+ZyEtb+DCIsaq9eFR1ZrgOJ+18hgXsV+IL4inluJs9teLG6lxz7kM+ 0y3zsEhtwNxYmsSMDI2AGzjZsrSB5Aps9j/x2TZ3L8pHECyemshDGcd3ukuXLrnRl6wEUqsXzRkc ylcsNgVK/rREeItnGTL4wzJaMPCFpow0U5iBNVBP6jgIxjKygNNg3LWmKapDcbsgl3MVKSmaijXq kMREwAZX66Tq/8ZMhB9KWoUa8j0+itwW6HX+hOaiJ3j2/z6vmh1aiz1F5I8vjlp6fjSBj2YThWYb GYJMWQKecUcOi94f0W0SvZobTKCfbrrJgvyY1W2u7m1J5FAKu6qKLdfRWAcy3HL5H6FTdUAmzcd1 /3VErrLluvfQE6ZmvefD1286AEpfoM2BqjA5JTu9qy3i3gOwtaHEUbQmMjjhrSEO7z8ID1BdTPmv CaVFY7aFZ2GxB/iXu0n3p/CI5c3KFNWTkFMAAAAAAAA= 146178 2014-08-23 14:18:50 +0000 2014-08-24 09:05:40 +0000 refactor arc reclaim logic arc-reclaim.patch text/plain 6953 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MDMxNSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTI2LDIwICsx MjYsNDIgQEAKIH0KIFNZU0lOSVQoa21lbV9zaXplX2luaXQsIFNJX1NVQl9LTUVNLCBTSV9PUkRF Ul9BTlksIGttZW1fc2l6ZV9pbml0LCBOVUxMKTsKIAorLyoKKyAqIFRoZSByZXR1cm5zIGZyb20g a21lbV9mcmVlXypzaXplIGFyZSBvbmx5IHZhbGlkIG9uY2UgdGhlIHBhZ2VkYWVtb24KKyAqIGhh cyBiZWVuIGluaXRpYWxpc2VkLCBiZWZvcmUgdGhlbiB0aGV5IHJldHVybiAwLgorICogCisgKiBU byBlbnN1cmUgdGhlIHJldHVybnMgYXJlIHZhbGlkIHRoZSBjYWxsZXIgY2FuIHVzZSBhIFNZU0lO SVQgd2l0aAorICogc3Vic3lzdGVtIHNldCB0byBTSV9TVUJfS1RIUkVBRF9QQUdFIGFuZCBvcmRl ciBvZiBhdCBsZWFzdAorICogU0lfT1JERVJfU0VDT05ELgorICovCiB1aW50NjRfdAota21lbV9z aXplKHZvaWQpCitrbWVtX2ZyZWVfdGFyZ2V0X3NpemUodm9pZCkKIHsKIAotCXJldHVybiAoa21l bV9zaXplX3ZhbCk7CisJcmV0dXJuICgodWludDY0X3QpY250LnZfZnJlZV90YXJnZXQgKiBQQUdF X1NJWkUpOwogfQogCiB1aW50NjRfdAota21lbV91c2VkKHZvaWQpCitrbWVtX2ZyZWVfbWluX3Np emUodm9pZCkKIHsKIAotCXJldHVybiAodm1lbV9zaXplKGttZW1fYXJlbmEsIFZNRU1fQUxMT0Mp KTsKKwlyZXR1cm4gKCh1aW50NjRfdCljbnQudl9mcmVlX21pbiAqIFBBR0VfU0laRSk7CiB9CiAK K3VpbnQ2NF90CitrbWVtX2ZyZWVfc2l6ZSh2b2lkKQoreworCisJcmV0dXJuICgodWludDY0X3Qp Y250LnZfZnJlZV9jb3VudCAqIFBBR0VfU0laRSk7Cit9CisKK3VpbnQ2NF90CitrbWVtX3NpemUo dm9pZCkKK3sKKworCXJldHVybiAoa21lbV9zaXplX3ZhbCk7Cit9CisKIHN0YXRpYyBpbnQKIGtt ZW1fc3RkX2NvbnN0cnVjdG9yKHZvaWQgKm1lbSwgaW50IHNpemUgX191bnVzZWQsIHZvaWQgKnBy aXZhdGUsIGludCBmbGFncykKIHsKSW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9z eXMva21lbS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMv a21lbS5oCShyZXZpc2lvbiAyNzAzMTUpCisrKyBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMv c3lzL2ttZW0uaAkod29ya2luZyBjb3B5KQpAQCAtNjYsNyArNjYsMTIgQEAKIHZvaWQgKnpmc19r bWVtX2FsbG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19rbWVtX2ZyZWUo dm9pZCAqYnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9pZCk7Ci11aW50 NjRfdCBrbWVtX3VzZWQodm9pZCk7CisKKy8qIFJldHVybiB2YWxzIGZyb20ga21lbV9mcmVlXypz aXplIGFyZSBvbmx5IHZhbGlkIGFmdGVyIHRoZSBwYWdlZGFlbW9uIGluaXQuICovCit1aW50NjRf dCBrbWVtX2ZyZWVfc2l6ZSh2b2lkKTsKK3VpbnQ2NF90IGttZW1fZnJlZV90YXJnZXRfc2l6ZSh2 b2lkKTsKK3VpbnQ2NF90IGttZW1fZnJlZV9taW5fc2l6ZSh2b2lkKTsKKwoga21lbV9jYWNoZV90 ICprbWVtX2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3QgYnVmc2l6ZSwgc2l6ZV90IGFs aWduLAogICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZvaWQgKiwgaW50KSwgdm9pZCAo KmRlc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lkICgqcmVjbGFpbSkodm9pZCAq KSBfX3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAsIGludCBjZmxhZ3MpOwpJbmRl eDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMv emZzL2FyYy5jCShyZXZpc2lvbiAyNzAzMTUpCisrKyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xh cmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3b3JraW5nIGNvcHkpCkBAIC0xOTMsOSArMTkz LDYgQEAKICAqLwogc3RhdGljIGJvb2xlYW5fdCBhcmNfd2FybTsKIAotLyoKLSAqIFRoZXNlIHR1 bmFibGVzIGFyZSBmb3IgcGVyZm9ybWFuY2UgYW5hbHlzaXMuCi0gKi8KIHVpbnQ2NF90IHpmc19h cmNfbWF4OwogdWludDY0X3QgemZzX2FyY19taW47CiB1aW50NjRfdCB6ZnNfYXJjX21ldGFfbGlt aXQgPSAwOwpAQCAtMjA0LDcgKzIwMSwyMCBAQAogaW50IHpmc19hcmNfcF9taW5fc2hpZnQgPSAw OwogaW50IHpmc19kaXNhYmxlX2R1cF9ldmljdGlvbiA9IDA7CiB1aW50NjRfdCB6ZnNfYXJjX2F2 ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEwMjQ7IC8qIDhLQiAqLwordWludDY0X3QgemZzX2FyY19m cmVlX3RhcmdldCA9ICgxIDw8IDMwKTsgLyogMUdCICovCiAKK3N0YXRpYyBpbnQgc3lzY3RsX3Zm c196ZnNfYXJjX2ZyZWVfdGFyZ2V0KFNZU0NUTF9IQU5ETEVSX0FSR1MpOworCitzdGF0aWMgdm9p ZAorYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQoreworCisJemZz X2FyY19mcmVlX3RhcmdldCA9IGttZW1fZnJlZV90YXJnZXRfc2l6ZSgpICogMzsKK30KK1NZU0lO SVQoYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX0FO WSwKKyAgICBhcmNfZnJlZV90YXJnZXRfaW5pdCwgTlVMTCk7CisKKwogVFVOQUJMRV9RVUFEKCJ2 ZnMuemZzLmFyY19tYXgiLCAmemZzX2FyY19tYXgpOwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFy Y19taW4iLCAmemZzX2FyY19taW4pOwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19tZXRhX2xp bWl0IiwgJnpmc19hcmNfbWV0YV9saW1pdCk7CkBAIC0yMTcsNyArMjI3LDM0IEBACiBTWVNDVExf VVFVQUQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfYXZlcmFnZV9ibG9ja3NpemUsIENUTEZMQUdf UkRUVU4sCiAgICAgJnpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUsIDAsCiAgICAgIkFSQyBhdmVy YWdlIGJsb2Nrc2l6ZSIpOworLyoKKyAqIFdlIGRvbid0IGhhdmUgYSB0dW5hYmxlIGZvciBhcmNf ZnJlZV90YXJnZXQgZHVlIHRvIHRoZSBkZXBlbmRlbmN5IG9uCisgKiBwYWdlZGFlbW9uIGluaXRp YWxpc2F0aW9uLgorICovCitTWVNDVExfUFJPQyhfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19mcmVl X3RhcmdldCwKKyAgICBDVExUWVBFX1U2NCB8IENUTEZMQUdfTVBTQUZFIHwgQ1RMRkxBR19SVywg MCwgc2l6ZW9mKHVpbnQ2NF90KSwKKyAgICBzeXNjdGxfdmZzX3pmc19hcmNfZnJlZV90YXJnZXQs ICJRVSIsCisgICAgIkRlc2lyZWQgYW1vdW50IG9mIGZyZWUgbWVtb3J5IGJlbG93IHdoaWNoIEFS QyB0cmlnZ2VycyByZWNsYWltIik7CiAKK3N0YXRpYyBpbnQKK3N5c2N0bF92ZnNfemZzX2FyY19m cmVlX3RhcmdldChTWVNDVExfSEFORExFUl9BUkdTKQoreworCXVpbnQ2NF90IHZhbDsKKwlpbnQg ZXJyOworCisJdmFsID0gemZzX2FyY19mcmVlX3RhcmdldDsKKwllcnIgPSBzeXNjdGxfaGFuZGxl XzY0KG9pZHAsICZ2YWwsIDAsIHJlcSk7CisJaWYgKGVyciAhPSAwIHx8IHJlcS0+bmV3cHRyID09 IE5VTEwpCisJCXJldHVybiAoZXJyKTsKKworCWlmICh2YWwgPCBrbWVtX2ZyZWVfbWluX3NpemUo KSkKKwkJcmV0dXJuIChFSU5WQUwpOworCisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZhbDsKKwor CXJldHVybiAoMCk7Cit9CisKIC8qCiAgKiBOb3RlIHRoYXQgYnVmZmVycyBjYW4gYmUgaW4gb25l IG9mIDYgc3RhdGVzOgogICoJQVJDX2Fub24JLSBhbm9ueW1vdXMgKGRpc2N1c3NlZCBiZWxvdykK QEAgLTI0MjEsOSArMjQ1OCwxMiBAQAogdm9pZAogYXJjX3Nocmluayh2b2lkKQogeworCiAJaWYg KGFyY19jID4gYXJjX2NfbWluKSB7CiAJCXVpbnQ2NF90IHRvX2ZyZWU7CiAKKwkJRFRSQUNFX1BS T0JFMihhcmNfX3NocmluaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRfdCwKKwkJCWFyY19jX21p bik7CiAjaWZkZWYgX0tFUk5FTAogCQl0b19mcmVlID0gYXJjX2MgPj4gYXJjX3Nocmlua19zaGlm dDsKICNlbHNlCkBAIC0yNDQzLDggKzI0ODMsMTEgQEAKIAkJQVNTRVJUKChpbnQ2NF90KWFyY19w ID49IDApOwogCX0KIAotCWlmIChhcmNfc2l6ZSA+IGFyY19jKQorCWlmIChhcmNfc2l6ZSA+IGFy Y19jKSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19zaHJpbmtfYWRqdXN0LCB1aW50NjRfdCwgYXJj X3NpemUsCisJCQl1aW50NjRfdCwgYXJjX2MpOwogCQlhcmNfYWRqdXN0KCk7CisJfQogfQogCiBz dGF0aWMgaW50IG5lZWRmcmVlID0gMDsKQEAgLTI0NTUsMTUgKzI0OTgsMjQgQEAKIAogI2lmZGVm IF9LRVJORUwKIAotCWlmIChuZWVkZnJlZSkKKwlpZiAobmVlZGZyZWUpIHsKKwkJRFRSQUNFX1BS T0JFKGFyY19fcmVjbGFpbV9uZWVkZnJlZSk7CiAJCXJldHVybiAoMSk7CisJfQogCisJaWYgKGtt ZW1fZnJlZV9zaXplKCkgPCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KSB7CisJCURUUkFDRV9QUk9CRShh cmNfX3JlY2xhaW1fZnJlZXRhcmdldCk7CisJCXJldHVybiAoMSk7CisJfQorCiAJLyoKIAkgKiBD b29wZXJhdGUgd2l0aCBwYWdlZGFlbW9uIHdoZW4gaXQncyB0aW1lIGZvciBpdCB0byBzY2FuCiAJ ICogYW5kIHJlY2xhaW0gc29tZSBwYWdlcy4KIAkgKi8KLQlpZiAodm1fcGFnaW5nX25lZWRlZCgp KQorCWlmICh2bV9wYWdpbmdfbmVlZGVkKCkpIHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFp bV9wYWdpbmcpOwogCQlyZXR1cm4gKDEpOworCX0KIAogI2lmZGVmIHN1bgogCS8qCkBAIC0yNTA3 LDkgKzI1NTksNiBAQAogCSAgICAoYnRvcCh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVF IHwgVk1FTV9BTExPQykpID4+IDIpKQogCQlyZXR1cm4gKDEpOwogI2VuZGlmCi0jZWxzZQkvKiAh c3VuICovCi0JaWYgKGttZW1fdXNlZCgpID4gKGttZW1fc2l6ZSgpICogMykgLyA0KQotCQlyZXR1 cm4gKDEpOwogI2VuZGlmCS8qIHN1biAqLwogCiAjZWxzZQpAQCAtMjUxNiw2ICsyNTY1LDggQEAK IAlpZiAoc3BhX2dldF9yYW5kb20oMTAwKSA9PSAwKQogCQlyZXR1cm4gKDEpOwogI2VuZGlmCisJ RFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9ubyk7CisKIAlyZXR1cm4gKDApOwogfQogCkluZGV4 OiBzeXMvdm0vdm1fcGFnZW91dC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy92bS92bV9wYWdlb3V0LmMJ KHJldmlzaW9uIDI3MDMxNSkKKysrIHN5cy92bS92bV9wYWdlb3V0LmMJKHdvcmtpbmcgY29weSkK QEAgLTExNSwxMCArMTE1LDE0IEBACiAKIC8qIHRoZSBrZXJuZWwgcHJvY2VzcyAidm1fcGFnZW91 dCIqLwogc3RhdGljIHZvaWQgdm1fcGFnZW91dCh2b2lkKTsKK3N0YXRpYyB2b2lkIHZtX3BhZ2Vv dXRfaW5pdCh2b2lkKTsKIHN0YXRpYyBpbnQgdm1fcGFnZW91dF9jbGVhbih2bV9wYWdlX3QpOwog c3RhdGljIHZvaWQgdm1fcGFnZW91dF9zY2FuKHN0cnVjdCB2bV9kb21haW4gKnZtZCwgaW50IHBh c3MpOwogc3RhdGljIHZvaWQgdm1fcGFnZW91dF9taWdodGJlX29vbShzdHJ1Y3Qgdm1fZG9tYWlu ICp2bWQsIGludCBwYXNzKTsKIAorU1lTSU5JVChwYWdlZGFlbW9uX2luaXQsIFNJX1NVQl9LVEhS RUFEX1BBR0UsIFNJX09SREVSX0ZJUlNULCB2bV9wYWdlb3V0X2luaXQsCisgICAgTlVMTCk7CisK IHN0cnVjdCBwcm9jICpwYWdlcHJvYzsKIAogc3RhdGljIHN0cnVjdCBrcHJvY19kZXNjIHBhZ2Vf a3AgPSB7CkBAIC0xMjYsNyArMTMwLDcgQEAKIAl2bV9wYWdlb3V0LAogCSZwYWdlcHJvYwogfTsK LVNZU0lOSVQocGFnZWRhZW1vbiwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfRklSU1Qs IGtwcm9jX3N0YXJ0LAorU1lTSU5JVChwYWdlZGFlbW9uLCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBT SV9PUkRFUl9TRUNPTkQsIGtwcm9jX3N0YXJ0LAogICAgICZwYWdlX2twKTsKIAogI2lmICFkZWZp bmVkKE5PX1NXQVBQSU5HKQpAQCAtMTY0NywxNSArMTY1MSwxMSBAQAogfQogCiAvKgotICoJdm1f cGFnZW91dCBpcyB0aGUgaGlnaCBsZXZlbCBwYWdlb3V0IGRhZW1vbi4KKyAqCXZtX3BhZ2VvdXRf aW5pdCBpbml0aWFsaXNlcyBiYXNpYyBwYWdlb3V0IGRhZW1vbiBzZXR0aW5ncy4KICAqLwogc3Rh dGljIHZvaWQKLXZtX3BhZ2VvdXQodm9pZCkKK3ZtX3BhZ2VvdXRfaW5pdCh2b2lkKQogewotI2lm IE1BWE1FTURPTSA+IDEKLQlpbnQgZXJyb3IsIGk7Ci0jZW5kaWYKLQogCS8qCiAJICogSW5pdGlh bGl6ZSBzb21lIHBhZ2luZyBwYXJhbWV0ZXJzLgogCSAqLwpAQCAtMTcwMSw3ICsxNzAxLDE4IEBA CiAJLyogWFhYIGRvZXMgbm90IHJlYWxseSBiZWxvbmcgaGVyZSAqLwogCWlmICh2bV9wYWdlX21h eF93aXJlZCA9PSAwKQogCQl2bV9wYWdlX21heF93aXJlZCA9IGNudC52X2ZyZWVfY291bnQgLyAz OworfQogCisvKgorICoJdm1fcGFnZW91dCBpcyB0aGUgaGlnaCBsZXZlbCBwYWdlb3V0IGRhZW1v bi4KKyAqLworc3RhdGljIHZvaWQKK3ZtX3BhZ2VvdXQodm9pZCkKK3sKKyNpZiBNQVhNRU1ET00g PiAxCisJaW50IGVycm9yLCBpOworI2VuZGlmCisKIAlzd2FwX3BhZ2VyX3N3YXBfaW5pdCgpOwog I2lmIE1BWE1FTURPTSA+IDEKIAlmb3IgKGkgPSAxOyBpIDwgdm1fbmRvbWFpbnM7IGkrKykgewo= 146203 2014-08-24 09:05:40 +0000 2014-08-27 23:18:01 +0000 refactor arc reclaim logic arc-reclaim.patch text/plain 7044 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MDMxNSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTI2LDIwICsx MjYsNDIgQEAKIH0KIFNZU0lOSVQoa21lbV9zaXplX2luaXQsIFNJX1NVQl9LTUVNLCBTSV9PUkRF Ul9BTlksIGttZW1fc2l6ZV9pbml0LCBOVUxMKTsKIAorLyoKKyAqIFRoZSByZXR1cm5zIGZyb20g a21lbV9mcmVlXypzaXplIGFyZSBvbmx5IHZhbGlkIG9uY2UgdGhlIHBhZ2VkYWVtb24KKyAqIGhh cyBiZWVuIGluaXRpYWxpc2VkLCBiZWZvcmUgdGhlbiB0aGV5IHJldHVybiAwLgorICogCisgKiBU byBlbnN1cmUgdGhlIHJldHVybnMgYXJlIHZhbGlkIHRoZSBjYWxsZXIgY2FuIHVzZSBhIFNZU0lO SVQgd2l0aAorICogc3Vic3lzdGVtIHNldCB0byBTSV9TVUJfS1RIUkVBRF9QQUdFIGFuZCBvcmRl ciBvZiBhdCBsZWFzdAorICogU0lfT1JERVJfU0VDT05ELgorICovCiB1aW50NjRfdAota21lbV9z aXplKHZvaWQpCitrbWVtX2ZyZWVfdGFyZ2V0X3NpemUodm9pZCkKIHsKIAotCXJldHVybiAoa21l bV9zaXplX3ZhbCk7CisJcmV0dXJuICgodWludDY0X3QpY250LnZfZnJlZV90YXJnZXQgKiBQQUdF X1NJWkUpOwogfQogCiB1aW50NjRfdAota21lbV91c2VkKHZvaWQpCitrbWVtX2ZyZWVfbWluX3Np emUodm9pZCkKIHsKIAotCXJldHVybiAodm1lbV9zaXplKGttZW1fYXJlbmEsIFZNRU1fQUxMT0Mp KTsKKwlyZXR1cm4gKCh1aW50NjRfdCljbnQudl9mcmVlX21pbiAqIFBBR0VfU0laRSk7CiB9CiAK K3VpbnQ2NF90CitrbWVtX2ZyZWVfc2l6ZSh2b2lkKQoreworCisJcmV0dXJuICgodWludDY0X3Qp Y250LnZfZnJlZV9jb3VudCAqIFBBR0VfU0laRSk7Cit9CisKK3VpbnQ2NF90CitrbWVtX3NpemUo dm9pZCkKK3sKKworCXJldHVybiAoa21lbV9zaXplX3ZhbCk7Cit9CisKIHN0YXRpYyBpbnQKIGtt ZW1fc3RkX2NvbnN0cnVjdG9yKHZvaWQgKm1lbSwgaW50IHNpemUgX191bnVzZWQsIHZvaWQgKnBy aXZhdGUsIGludCBmbGFncykKIHsKSW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9z eXMva21lbS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMv a21lbS5oCShyZXZpc2lvbiAyNzAzMTUpCisrKyBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMv c3lzL2ttZW0uaAkod29ya2luZyBjb3B5KQpAQCAtNjYsNyArNjYsMTIgQEAKIHZvaWQgKnpmc19r bWVtX2FsbG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19rbWVtX2ZyZWUo dm9pZCAqYnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9pZCk7Ci11aW50 NjRfdCBrbWVtX3VzZWQodm9pZCk7CisKKy8qIFJldHVybiB2YWxzIGZyb20ga21lbV9mcmVlXypz aXplIGFyZSBvbmx5IHZhbGlkIGFmdGVyIHRoZSBwYWdlZGFlbW9uIGluaXQuICovCit1aW50NjRf dCBrbWVtX2ZyZWVfc2l6ZSh2b2lkKTsKK3VpbnQ2NF90IGttZW1fZnJlZV90YXJnZXRfc2l6ZSh2 b2lkKTsKK3VpbnQ2NF90IGttZW1fZnJlZV9taW5fc2l6ZSh2b2lkKTsKKwoga21lbV9jYWNoZV90 ICprbWVtX2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3QgYnVmc2l6ZSwgc2l6ZV90IGFs aWduLAogICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZvaWQgKiwgaW50KSwgdm9pZCAo KmRlc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lkICgqcmVjbGFpbSkodm9pZCAq KSBfX3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAsIGludCBjZmxhZ3MpOwpJbmRl eDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMv emZzL2FyYy5jCShyZXZpc2lvbiAyNzAzMTUpCisrKyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xh cmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3b3JraW5nIGNvcHkpCkBAIC0xOTMsOSArMTkz LDYgQEAKICAqLwogc3RhdGljIGJvb2xlYW5fdCBhcmNfd2FybTsKIAotLyoKLSAqIFRoZXNlIHR1 bmFibGVzIGFyZSBmb3IgcGVyZm9ybWFuY2UgYW5hbHlzaXMuCi0gKi8KIHVpbnQ2NF90IHpmc19h cmNfbWF4OwogdWludDY0X3QgemZzX2FyY19taW47CiB1aW50NjRfdCB6ZnNfYXJjX21ldGFfbGlt aXQgPSAwOwpAQCAtMjA0LDcgKzIwMSwyMiBAQAogaW50IHpmc19hcmNfcF9taW5fc2hpZnQgPSAw OwogaW50IHpmc19kaXNhYmxlX2R1cF9ldmljdGlvbiA9IDA7CiB1aW50NjRfdCB6ZnNfYXJjX2F2 ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEwMjQ7IC8qIDhLQiAqLwordWludDY0X3QgemZzX2FyY19m cmVlX3RhcmdldCA9ICgxIDw8IDMwKTsgLyogMUdCICovCiAKK3N0YXRpYyBpbnQgc3lzY3RsX3Zm c196ZnNfYXJjX2ZyZWVfdGFyZ2V0KFNZU0NUTF9IQU5ETEVSX0FSR1MpOworCisjaWZkZWYgX0tF Uk5FTAorc3RhdGljIHZvaWQKK2FyY19mcmVlX3RhcmdldF9pbml0KHZvaWQgKnVudXNlZCBfX3Vu dXNlZCkKK3sKKworCXpmc19hcmNfZnJlZV90YXJnZXQgPSBrbWVtX2ZyZWVfdGFyZ2V0X3NpemUo KSAqIDM7Cit9CitTWVNJTklUKGFyY19mcmVlX3RhcmdldF9pbml0LCBTSV9TVUJfS1RIUkVBRF9Q QUdFLCBTSV9PUkRFUl9BTlksCisgICAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIE5VTEwpOworI2Vu ZGlmCisKKwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19tYXgiLCAmemZzX2FyY19tYXgpOwog VFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19taW4iLCAmemZzX2FyY19taW4pOwogVFVOQUJMRV9R VUFEKCJ2ZnMuemZzLmFyY19tZXRhX2xpbWl0IiwgJnpmc19hcmNfbWV0YV9saW1pdCk7CkBAIC0y MTcsNyArMjI5LDM0IEBACiBTWVNDVExfVVFVQUQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfYXZl cmFnZV9ibG9ja3NpemUsIENUTEZMQUdfUkRUVU4sCiAgICAgJnpmc19hcmNfYXZlcmFnZV9ibG9j a3NpemUsIDAsCiAgICAgIkFSQyBhdmVyYWdlIGJsb2Nrc2l6ZSIpOworLyoKKyAqIFdlIGRvbid0 IGhhdmUgYSB0dW5hYmxlIGZvciBhcmNfZnJlZV90YXJnZXQgZHVlIHRvIHRoZSBkZXBlbmRlbmN5 IG9uCisgKiBwYWdlZGFlbW9uIGluaXRpYWxpc2F0aW9uLgorICovCitTWVNDVExfUFJPQyhfdmZz X3pmcywgT0lEX0FVVE8sIGFyY19mcmVlX3RhcmdldCwKKyAgICBDVExUWVBFX1U2NCB8IENUTEZM QUdfTVBTQUZFIHwgQ1RMRkxBR19SVywgMCwgc2l6ZW9mKHVpbnQ2NF90KSwKKyAgICBzeXNjdGxf dmZzX3pmc19hcmNfZnJlZV90YXJnZXQsICJRVSIsCisgICAgIkRlc2lyZWQgYW1vdW50IG9mIGZy ZWUgbWVtb3J5IGJlbG93IHdoaWNoIEFSQyB0cmlnZ2VycyByZWNsYWltIik7CiAKK3N0YXRpYyBp bnQKK3N5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldChTWVNDVExfSEFORExFUl9BUkdTKQor eworCXVpbnQ2NF90IHZhbDsKKwlpbnQgZXJyOworCisJdmFsID0gemZzX2FyY19mcmVlX3Rhcmdl dDsKKwllcnIgPSBzeXNjdGxfaGFuZGxlXzY0KG9pZHAsICZ2YWwsIDAsIHJlcSk7CisJaWYgKGVy ciAhPSAwIHx8IHJlcS0+bmV3cHRyID09IE5VTEwpCisJCXJldHVybiAoZXJyKTsKKworCWlmICh2 YWwgPCBrbWVtX2ZyZWVfbWluX3NpemUoKSkKKwkJcmV0dXJuIChFSU5WQUwpOworCisJemZzX2Fy Y19mcmVlX3RhcmdldCA9IHZhbDsKKworCXJldHVybiAoMCk7Cit9CisKIC8qCiAgKiBOb3RlIHRo YXQgYnVmZmVycyBjYW4gYmUgaW4gb25lIG9mIDYgc3RhdGVzOgogICoJQVJDX2Fub24JLSBhbm9u eW1vdXMgKGRpc2N1c3NlZCBiZWxvdykKQEAgLTI0MjEsOSArMjQ2MCwxMiBAQAogdm9pZAogYXJj X3Nocmluayh2b2lkKQogeworCiAJaWYgKGFyY19jID4gYXJjX2NfbWluKSB7CiAJCXVpbnQ2NF90 IHRvX2ZyZWU7CiAKKwkJRFRSQUNFX1BST0JFMihhcmNfX3NocmluaywgdWludDY0X3QsIGFyY19j LCB1aW50NjRfdCwKKwkJCWFyY19jX21pbik7CiAjaWZkZWYgX0tFUk5FTAogCQl0b19mcmVlID0g YXJjX2MgPj4gYXJjX3Nocmlua19zaGlmdDsKICNlbHNlCkBAIC0yNDQzLDggKzI0ODUsMTEgQEAK IAkJQVNTRVJUKChpbnQ2NF90KWFyY19wID49IDApOwogCX0KIAotCWlmIChhcmNfc2l6ZSA+IGFy Y19jKQorCWlmIChhcmNfc2l6ZSA+IGFyY19jKSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19zaHJp bmtfYWRqdXN0LCB1aW50NjRfdCwgYXJjX3NpemUsCisJCQl1aW50NjRfdCwgYXJjX2MpOwogCQlh cmNfYWRqdXN0KCk7CisJfQogfQogCiBzdGF0aWMgaW50IG5lZWRmcmVlID0gMDsKQEAgLTI0NTUs MTUgKzI1MDAsMjUgQEAKIAogI2lmZGVmIF9LRVJORUwKIAotCWlmIChuZWVkZnJlZSkKKwlpZiAo bmVlZGZyZWUpIHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9uZWVkZnJlZSk7CiAJCXJl dHVybiAoMSk7CisJfQogCisJaWYgKGttZW1fZnJlZV9zaXplKCkgPCB6ZnNfYXJjX2ZyZWVfdGFy Z2V0KSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19yZWNsYWltX2ZyZWV0YXJnZXQsIHVpbnQ2NF90 LAorCQkgICAga21lbV9mcmVlX3NpemUoKSwgdWludDY0X3QsIHpmc19hcmNfZnJlZV90YXJnZXQp OworCQlyZXR1cm4gKDEpOworCX0KKwogCS8qCiAJICogQ29vcGVyYXRlIHdpdGggcGFnZWRhZW1v biB3aGVuIGl0J3MgdGltZSBmb3IgaXQgdG8gc2NhbgogCSAqIGFuZCByZWNsYWltIHNvbWUgcGFn ZXMuCiAJICovCi0JaWYgKHZtX3BhZ2luZ19uZWVkZWQoKSkKKwlpZiAodm1fcGFnaW5nX25lZWRl ZCgpKSB7CisJCURUUkFDRV9QUk9CRShhcmNfX3JlY2xhaW1fcGFnaW5nKTsKIAkJcmV0dXJuICgx KTsKKwl9CiAKICNpZmRlZiBzdW4KIAkvKgpAQCAtMjUwNyw5ICsyNTYyLDYgQEAKIAkgICAgKGJ0 b3Aodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+PiAyKSkK IAkJcmV0dXJuICgxKTsKICNlbmRpZgotI2Vsc2UJLyogIXN1biAqLwotCWlmIChrbWVtX3VzZWQo KSA+IChrbWVtX3NpemUoKSAqIDMpIC8gNCkKLQkJcmV0dXJuICgxKTsKICNlbmRpZgkvKiBzdW4g Ki8KIAogI2Vsc2UKQEAgLTI1MTYsNiArMjU2OCw4IEBACiAJaWYgKHNwYV9nZXRfcmFuZG9tKDEw MCkgPT0gMCkKIAkJcmV0dXJuICgxKTsKICNlbmRpZgorCURUUkFDRV9QUk9CRShhcmNfX3JlY2xh aW1fbm8pOworCiAJcmV0dXJuICgwKTsKIH0KIApJbmRleDogc3lzL3ZtL3ZtX3BhZ2VvdXQuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBzeXMvdm0vdm1fcGFnZW91dC5jCShyZXZpc2lvbiAyNzAzMTUpCisrKyBz eXMvdm0vdm1fcGFnZW91dC5jCSh3b3JraW5nIGNvcHkpCkBAIC0xMTUsMTAgKzExNSwxNCBAQAog CiAvKiB0aGUga2VybmVsIHByb2Nlc3MgInZtX3BhZ2VvdXQiKi8KIHN0YXRpYyB2b2lkIHZtX3Bh Z2VvdXQodm9pZCk7CitzdGF0aWMgdm9pZCB2bV9wYWdlb3V0X2luaXQodm9pZCk7CiBzdGF0aWMg aW50IHZtX3BhZ2VvdXRfY2xlYW4odm1fcGFnZV90KTsKIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXRf c2NhbihzdHJ1Y3Qgdm1fZG9tYWluICp2bWQsIGludCBwYXNzKTsKIHN0YXRpYyB2b2lkIHZtX3Bh Z2VvdXRfbWlnaHRiZV9vb20oc3RydWN0IHZtX2RvbWFpbiAqdm1kLCBpbnQgcGFzcyk7CiAKK1NZ U0lOSVQocGFnZWRhZW1vbl9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9GSVJT VCwgdm1fcGFnZW91dF9pbml0LAorICAgIE5VTEwpOworCiBzdHJ1Y3QgcHJvYyAqcGFnZXByb2M7 CiAKIHN0YXRpYyBzdHJ1Y3Qga3Byb2NfZGVzYyBwYWdlX2twID0gewpAQCAtMTI2LDcgKzEzMCw3 IEBACiAJdm1fcGFnZW91dCwKIAkmcGFnZXByb2MKIH07Ci1TWVNJTklUKHBhZ2VkYWVtb24sIFNJ X1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX0ZJUlNULCBrcHJvY19zdGFydCwKK1NZU0lOSVQo cGFnZWRhZW1vbiwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfU0VDT05ELCBrcHJvY19z dGFydCwKICAgICAmcGFnZV9rcCk7CiAKICNpZiAhZGVmaW5lZChOT19TV0FQUElORykKQEAgLTE2 NDcsMTUgKzE2NTEsMTEgQEAKIH0KIAogLyoKLSAqCXZtX3BhZ2VvdXQgaXMgdGhlIGhpZ2ggbGV2 ZWwgcGFnZW91dCBkYWVtb24uCisgKgl2bV9wYWdlb3V0X2luaXQgaW5pdGlhbGlzZXMgYmFzaWMg cGFnZW91dCBkYWVtb24gc2V0dGluZ3MuCiAgKi8KIHN0YXRpYyB2b2lkCi12bV9wYWdlb3V0KHZv aWQpCit2bV9wYWdlb3V0X2luaXQodm9pZCkKIHsKLSNpZiBNQVhNRU1ET00gPiAxCi0JaW50IGVy cm9yLCBpOwotI2VuZGlmCi0KIAkvKgogCSAqIEluaXRpYWxpemUgc29tZSBwYWdpbmcgcGFyYW1l dGVycy4KIAkgKi8KQEAgLTE3MDEsNyArMTcwMSwxOCBAQAogCS8qIFhYWCBkb2VzIG5vdCByZWFs bHkgYmVsb25nIGhlcmUgKi8KIAlpZiAodm1fcGFnZV9tYXhfd2lyZWQgPT0gMCkKIAkJdm1fcGFn ZV9tYXhfd2lyZWQgPSBjbnQudl9mcmVlX2NvdW50IC8gMzsKK30KIAorLyoKKyAqCXZtX3BhZ2Vv dXQgaXMgdGhlIGhpZ2ggbGV2ZWwgcGFnZW91dCBkYWVtb24uCisgKi8KK3N0YXRpYyB2b2lkCit2 bV9wYWdlb3V0KHZvaWQpCit7CisjaWYgTUFYTUVNRE9NID4gMQorCWludCBlcnJvciwgaTsKKyNl bmRpZgorCiAJc3dhcF9wYWdlcl9zd2FwX2luaXQoKTsKICNpZiBNQVhNRU1ET00gPiAxCiAJZm9y IChpID0gMTsgaSA8IHZtX25kb21haW5zOyBpKyspIHsK 146249 2014-08-25 10:35:12 +0000 2014-08-27 12:20:46 +0000 arc reclaim refactor (against head) arc-reclaim-head.patch text/plain 7456 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MDQyMikKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTI2LDIwICsx MjYsNDIgQEAga21lbV9zaXplX2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQogfQogU1lTSU5J VChrbWVtX3NpemVfaW5pdCwgU0lfU1VCX0tNRU0sIFNJX09SREVSX0FOWSwga21lbV9zaXplX2lu aXQsIE5VTEwpOwogCisvKgorICogVGhlIHJldHVybnMgZnJvbSBrbWVtX2ZyZWVfKnNpemUgYXJl IG9ubHkgdmFsaWQgb25jZSB0aGUgcGFnZWRhZW1vbgorICogaGFzIGJlZW4gaW5pdGlhbGlzZWQs IGJlZm9yZSB0aGVuIHRoZXkgcmV0dXJuIDAuCisgKiAKKyAqIFRvIGVuc3VyZSB0aGUgcmV0dXJu cyBhcmUgdmFsaWQgdGhlIGNhbGxlciBjYW4gdXNlIGEgU1lTSU5JVCB3aXRoCisgKiBzdWJzeXN0 ZW0gc2V0IHRvIFNJX1NVQl9LVEhSRUFEX1BBR0UgYW5kIG9yZGVyIG9mIGF0IGxlYXN0CisgKiBT SV9PUkRFUl9TRUNPTkQuCisgKi8KIHVpbnQ2NF90Ci1rbWVtX3NpemUodm9pZCkKK2ttZW1fZnJl ZV90YXJnZXRfc2l6ZSh2b2lkKQogewogCi0JcmV0dXJuIChrbWVtX3NpemVfdmFsKTsKKwlyZXR1 cm4gKCh1aW50NjRfdCl2bV9jbnQudl9mcmVlX3RhcmdldCAqIFBBR0VfU0laRSk7CiB9CiAKIHVp bnQ2NF90Ci1rbWVtX3VzZWQodm9pZCkKK2ttZW1fZnJlZV9taW5fc2l6ZSh2b2lkKQogewogCi0J cmV0dXJuICh2bWVtX3NpemUoa21lbV9hcmVuYSwgVk1FTV9BTExPQykpOworCXJldHVybiAoKHVp bnQ2NF90KXZtX2NudC52X2ZyZWVfbWluICogUEFHRV9TSVpFKTsKIH0KIAordWludDY0X3QKK2tt ZW1fZnJlZV9zaXplKHZvaWQpCit7CisKKwlyZXR1cm4gKCh1aW50NjRfdCl2bV9jbnQudl9mcmVl X2NvdW50ICogUEFHRV9TSVpFKTsKK30KKwordWludDY0X3QKK2ttZW1fc2l6ZSh2b2lkKQorewor CisJcmV0dXJuIChrbWVtX3NpemVfdmFsKTsKK30KKwogc3RhdGljIGludAoga21lbV9zdGRfY29u c3RydWN0b3Iodm9pZCAqbWVtLCBpbnQgc2l6ZSBfX3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgaW50 IGZsYWdzKQogewpJbmRleDogc3lzL2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgJKHJl dmlzaW9uIDI3MDQyMikKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5o CSh3b3JraW5nIGNvcHkpCkBAIC02Niw3ICs2NiwxMiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2Nh Y2hlIHsKIHZvaWQgKnpmc19rbWVtX2FsbG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2 b2lkIHpmc19rbWVtX2ZyZWUodm9pZCAqYnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVt X3NpemUodm9pZCk7Ci11aW50NjRfdCBrbWVtX3VzZWQodm9pZCk7CisKKy8qIFJldHVybiB2YWxz IGZyb20ga21lbV9mcmVlXypzaXplIGFyZSBvbmx5IHZhbGlkIGFmdGVyIHRoZSBwYWdlZGFlbW9u IGluaXQuICovCit1aW50NjRfdCBrbWVtX2ZyZWVfc2l6ZSh2b2lkKTsKK3VpbnQ2NF90IGttZW1f ZnJlZV90YXJnZXRfc2l6ZSh2b2lkKTsKK3VpbnQ2NF90IGttZW1fZnJlZV9taW5fc2l6ZSh2b2lk KTsKKwoga21lbV9jYWNoZV90ICprbWVtX2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3Qg YnVmc2l6ZSwgc2l6ZV90IGFsaWduLAogICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZv aWQgKiwgaW50KSwgdm9pZCAoKmRlc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lk ICgqcmVjbGFpbSkodm9pZCAqKSBfX3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAs IGludCBjZmxhZ3MpOwpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29t bW9uL2ZzL3pmcy9hcmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xh cmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzA0MjIpCisrKyBzeXMvY2Rk bC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3b3JraW5nIGNv cHkpCkBAIC0xOTMsOSArMTkzLDYgQEAgZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hfZGlzYWJsZTsK ICAqLwogc3RhdGljIGJvb2xlYW5fdCBhcmNfd2FybTsKIAotLyoKLSAqIFRoZXNlIHR1bmFibGVz IGFyZSBmb3IgcGVyZm9ybWFuY2UgYW5hbHlzaXMuCi0gKi8KIHVpbnQ2NF90IHpmc19hcmNfbWF4 OwogdWludDY0X3QgemZzX2FyY19taW47CiB1aW50NjRfdCB6ZnNfYXJjX21ldGFfbGltaXQgPSAw OwpAQCAtMjA0LDcgKzIwMSwyMSBAQCBpbnQgemZzX2FyY19zaHJpbmtfc2hpZnQgPSAwOwogaW50 IHpmc19hcmNfcF9taW5fc2hpZnQgPSAwOwogaW50IHpmc19kaXNhYmxlX2R1cF9ldmljdGlvbiA9 IDA7CiB1aW50NjRfdCB6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEwMjQ7IC8qIDhL QiAqLwordWludDY0X3QgemZzX2FyY19mcmVlX3RhcmdldCA9ICgxIDw8IDMwKTsgLyogMUdCICov CiAKK3N0YXRpYyBpbnQgc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0KFNZU0NUTF9IQU5E TEVSX0FSR1MpOworCisjaWZkZWYgX0tFUk5FTAorc3RhdGljIHZvaWQKK2FyY19mcmVlX3Rhcmdl dF9pbml0KHZvaWQgKnVudXNlZCBfX3VudXNlZCkKK3sKKworCXpmc19hcmNfZnJlZV90YXJnZXQg PSBrbWVtX2ZyZWVfdGFyZ2V0X3NpemUoKSAqIDM7Cit9CitTWVNJTklUKGFyY19mcmVlX3Rhcmdl dF9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9BTlksCisgICAgYXJjX2ZyZWVf dGFyZ2V0X2luaXQsIE5VTEwpOworI2VuZGlmCisKIFRVTkFCTEVfUVVBRCgidmZzLnpmcy5hcmNf bWV0YV9saW1pdCIsICZ6ZnNfYXJjX21ldGFfbGltaXQpOwogU1lTQ1RMX0RFQ0woX3Zmc196ZnMp OwogU1lTQ1RMX1VRVUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX21heCwgQ1RMRkxBR19SRFRV TiwgJnpmc19hcmNfbWF4LCAwLApAQCAtMjE0LDcgKzIyNSwzNCBAQCBTWVNDVExfVVFVQUQoX3Zm c196ZnMsIE9JRF9BVVRPLCBhcmNfbWluLCBDVExGTEFHXwogU1lTQ1RMX1VRVUFEKF92ZnNfemZz LCBPSURfQVVUTywgYXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCBDVExGTEFHX1JEVFVOLAogICAgICZ6 ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCAwLAogICAgICJBUkMgYXZlcmFnZSBibG9ja3NpemUi KTsKKy8qCisgKiBXZSBkb24ndCBoYXZlIGEgdHVuYWJsZSBmb3IgYXJjX2ZyZWVfdGFyZ2V0IGR1 ZSB0byB0aGUgZGVwZW5kZW5jeSBvbgorICogcGFnZWRhZW1vbiBpbml0aWFsaXNhdGlvbi4KKyAq LworU1lTQ1RMX1BST0MoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfZnJlZV90YXJnZXQsCisgICAg Q1RMVFlQRV9VNjQgfCBDVExGTEFHX01QU0FGRSB8IENUTEZMQUdfUlcsIDAsIHNpemVvZih1aW50 NjRfdCksCisgICAgc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0LCAiUVUiLAorICAgICJE ZXNpcmVkIGFtb3VudCBvZiBmcmVlIG1lbW9yeSBiZWxvdyB3aGljaCBBUkMgdHJpZ2dlcnMgcmVj bGFpbSIpOwogCitzdGF0aWMgaW50CitzeXNjdGxfdmZzX3pmc19hcmNfZnJlZV90YXJnZXQoU1lT Q1RMX0hBTkRMRVJfQVJHUykKK3sKKwl1aW50NjRfdCB2YWw7CisJaW50IGVycjsKKworCXZhbCA9 IHpmc19hcmNfZnJlZV90YXJnZXQ7CisJZXJyID0gc3lzY3RsX2hhbmRsZV82NChvaWRwLCAmdmFs LCAwLCByZXEpOworCWlmIChlcnIgIT0gMCB8fCByZXEtPm5ld3B0ciA9PSBOVUxMKQorCQlyZXR1 cm4gKGVycik7CisKKwlpZiAodmFsIDwga21lbV9mcmVlX21pbl9zaXplKCkpCisJCXJldHVybiAo RUlOVkFMKTsKKworCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2YWw7CisKKwlyZXR1cm4gKDApOwor fQorCiAvKgogICogTm90ZSB0aGF0IGJ1ZmZlcnMgY2FuIGJlIGluIG9uZSBvZiA2IHN0YXRlczoK ICAqCUFSQ19hbm9uCS0gYW5vbnltb3VzIChkaXNjdXNzZWQgYmVsb3cpCkBAIC0yNDE4LDkgKzI0 NTYsMTIgQEAgYXJjX2ZsdXNoKHNwYV90ICpzcGEpCiB2b2lkCiBhcmNfc2hyaW5rKHZvaWQpCiB7 CisKIAlpZiAoYXJjX2MgPiBhcmNfY19taW4pIHsKIAkJdWludDY0X3QgdG9fZnJlZTsKIAorCQlE VFJBQ0VfUFJPQkUyKGFyY19fc2hyaW5rLCB1aW50NjRfdCwgYXJjX2MsIHVpbnQ2NF90LAorCQkJ YXJjX2NfbWluKTsKICNpZmRlZiBfS0VSTkVMCiAJCXRvX2ZyZWUgPSBhcmNfYyA+PiBhcmNfc2hy aW5rX3NoaWZ0OwogI2Vsc2UKQEAgLTI0NDAsOCArMjQ4MSwxMSBAQCBhcmNfc2hyaW5rKHZvaWQp CiAJCUFTU0VSVCgoaW50NjRfdClhcmNfcCA+PSAwKTsKIAl9CiAKLQlpZiAoYXJjX3NpemUgPiBh cmNfYykKKwlpZiAoYXJjX3NpemUgPiBhcmNfYykgeworCQlEVFJBQ0VfUFJPQkUyKGFyY19fc2hy aW5rX2FkanVzdCwgdWludDY0X3QsIGFyY19zaXplLAorCQkJdWludDY0X3QsIGFyY19jKTsKIAkJ YXJjX2FkanVzdCgpOworCX0KIH0KIAogc3RhdGljIGludCBuZWVkZnJlZSA9IDA7CkBAIC0yNDUy LDE1ICsyNDk2LDI1IEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogCiAjaWZkZWYgX0tFUk5F TAogCi0JaWYgKG5lZWRmcmVlKQorCWlmIChuZWVkZnJlZSkgeworCQlEVFJBQ0VfUFJPQkUoYXJj X19yZWNsYWltX25lZWRmcmVlKTsKIAkJcmV0dXJuICgxKTsKKwl9CiAKKwlpZiAoa21lbV9mcmVl X3NpemUoKSA8IHpmc19hcmNfZnJlZV90YXJnZXQpIHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3Jl Y2xhaW1fZnJlZXRhcmdldCwgdWludDY0X3QsCisJCSAgICBrbWVtX2ZyZWVfc2l6ZSgpLCB1aW50 NjRfdCwgemZzX2FyY19mcmVlX3RhcmdldCk7CisJCXJldHVybiAoMSk7CisJfQorCiAJLyoKIAkg KiBDb29wZXJhdGUgd2l0aCBwYWdlZGFlbW9uIHdoZW4gaXQncyB0aW1lIGZvciBpdCB0byBzY2Fu CiAJICogYW5kIHJlY2xhaW0gc29tZSBwYWdlcy4KIAkgKi8KLQlpZiAodm1fcGFnaW5nX25lZWRl ZCgpKQorCWlmICh2bV9wYWdpbmdfbmVlZGVkKCkpIHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVj bGFpbV9wYWdpbmcpOwogCQlyZXR1cm4gKDEpOworCX0KIAogI2lmZGVmIHN1bgogCS8qCkBAIC0y NTA0LDkgKzI1NTgsNiBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIAkgICAgKGJ0b3Aodm1l bV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+PiAyKSkKIAkJcmV0 dXJuICgxKTsKICNlbmRpZgotI2Vsc2UJLyogIXN1biAqLwotCWlmIChrbWVtX3VzZWQoKSA+IChr bWVtX3NpemUoKSAqIDMpIC8gNCkKLQkJcmV0dXJuICgxKTsKICNlbmRpZgkvKiBzdW4gKi8KIAog I2Vsc2UKQEAgLTI1MTMsNiArMjU2NCw4IEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogCWlm IChzcGFfZ2V0X3JhbmRvbSgxMDApID09IDApCiAJCXJldHVybiAoMSk7CiAjZW5kaWYKKwlEVFJB Q0VfUFJPQkUoYXJjX19yZWNsYWltX25vKTsKKwogCXJldHVybiAoMCk7CiB9CiAKSW5kZXg6IHN5 cy92bS92bV9wYWdlb3V0LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkocmV2 aXNpb24gMjcwNDIyKQorKysgc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkod29ya2luZyBjb3B5KQpAQCAt MTE1LDEwICsxMTUsMTQgQEAgX19GQlNESUQoIiRGcmVlQlNEJCIpOwogCiAvKiB0aGUga2VybmVs IHByb2Nlc3MgInZtX3BhZ2VvdXQiKi8KIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXQodm9pZCk7Citz dGF0aWMgdm9pZCB2bV9wYWdlb3V0X2luaXQodm9pZCk7CiBzdGF0aWMgaW50IHZtX3BhZ2VvdXRf Y2xlYW4odm1fcGFnZV90KTsKIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXRfc2NhbihzdHJ1Y3Qgdm1f ZG9tYWluICp2bWQsIGludCBwYXNzKTsKIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXRfbWlnaHRiZV9v b20oc3RydWN0IHZtX2RvbWFpbiAqdm1kLCBpbnQgcGFzcyk7CiAKK1NZU0lOSVQocGFnZWRhZW1v bl9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9GSVJTVCwgdm1fcGFnZW91dF9p bml0LAorICAgIE5VTEwpOworCiBzdHJ1Y3QgcHJvYyAqcGFnZXByb2M7CiAKIHN0YXRpYyBzdHJ1 Y3Qga3Byb2NfZGVzYyBwYWdlX2twID0gewpAQCAtMTI2LDcgKzEzMCw3IEBAIHN0YXRpYyBzdHJ1 Y3Qga3Byb2NfZGVzYyBwYWdlX2twID0gewogCXZtX3BhZ2VvdXQsCiAJJnBhZ2Vwcm9jCiB9Owot U1lTSU5JVChwYWdlZGFlbW9uLCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9GSVJTVCwg a3Byb2Nfc3RhcnQsCitTWVNJTklUKHBhZ2VkYWVtb24sIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJ X09SREVSX1NFQ09ORCwga3Byb2Nfc3RhcnQsCiAgICAgJnBhZ2Vfa3ApOwogCiAjaWYgIWRlZmlu ZWQoTk9fU1dBUFBJTkcpCkBAIC0xNjM3LDE1ICsxNjQxLDExIEBAIHZtX3BhZ2VvdXRfd29ya2Vy KHZvaWQgKmFyZykKIH0KIAogLyoKLSAqCXZtX3BhZ2VvdXQgaXMgdGhlIGhpZ2ggbGV2ZWwgcGFn ZW91dCBkYWVtb24uCisgKgl2bV9wYWdlb3V0X2luaXQgaW5pdGlhbGlzZXMgYmFzaWMgcGFnZW91 dCBkYWVtb24gc2V0dGluZ3MuCiAgKi8KIHN0YXRpYyB2b2lkCi12bV9wYWdlb3V0KHZvaWQpCit2 bV9wYWdlb3V0X2luaXQodm9pZCkKIHsKLSNpZiBNQVhNRU1ET00gPiAxCi0JaW50IGVycm9yLCBp OwotI2VuZGlmCi0KIAkvKgogCSAqIEluaXRpYWxpemUgc29tZSBwYWdpbmcgcGFyYW1ldGVycy4K IAkgKi8KQEAgLTE2OTEsNyArMTY5MSwxOCBAQCBzdGF0aWMgdm9pZAogCS8qIFhYWCBkb2VzIG5v dCByZWFsbHkgYmVsb25nIGhlcmUgKi8KIAlpZiAodm1fcGFnZV9tYXhfd2lyZWQgPT0gMCkKIAkJ dm1fcGFnZV9tYXhfd2lyZWQgPSB2bV9jbnQudl9mcmVlX2NvdW50IC8gMzsKK30KIAorLyoKKyAq ICAgICB2bV9wYWdlb3V0IGlzIHRoZSBoaWdoIGxldmVsIHBhZ2VvdXQgZGFlbW9uLgorICovCitz dGF0aWMgdm9pZAordm1fcGFnZW91dCh2b2lkKQoreworI2lmIE1BWE1FTURPTSA+IDEKKwlpbnQg ZXJyb3IsIGk7CisjZW5kaWYKKwogCXN3YXBfcGFnZXJfc3dhcF9pbml0KCk7CiAjaWYgTUFYTUVN RE9NID4gMQogCWZvciAoaSA9IDE7IGkgPCB2bV9uZG9tYWluczsgaSsrKSB7Cg== 146251 2014-08-25 12:52:47 +0000 2014-08-26 02:48:41 +0000 From comment #10 file_187594.txt text/plain 9825 karl KioqIGFyYy5jLm9yaWdpbmFsCVN1biBNYXIgMjMgMTQ6NTY6MDEgMjAxNA0KLS0tIGFyYy5jCVR1 ZSBNYXIgMjUgMDk6MjQ6MTQgMjAxNA0KKioqKioqKioqKioqKioqDQoqKiogMTgsMjMgKioqKg0K LS0tIDE4LDk1IC0tLS0NCiAgICoNCiAgICogQ0RETCBIRUFERVIgRU5EDQogICAqLw0KKyANCisg LyogS2FybCBEZW5uaW5nZXIgKGthcmxAZGVubmluZ2VyLm5ldCksIDMvMjUvMjAxNCwgRnJlZUJT RC1zcGVjaWZpYw0KKyAgKiANCisgICogSWYgIk5FV1JFQ0xBSU0iIGlzIGRlZmluZWQsIGNoYW5n ZSB0aGUgImxvdyBtZW1vcnkiIHdhcm5pbmcgdGhhdCBjYXVzZXMNCisgICogdGhlIEFSQyBjYWNo ZSB0byBiZSBwYXJlZCBkb3duLiAgVGhlIHJlYXNvbiBmb3IgdGhlIGNoYW5nZSBpcyB0aGF0IHRo ZQ0KKyAgKiBhcHBhcmVudCBhdHRlbXB0ZWQgYWxnb3JpdGhtIGlzIHRvIHN0YXJ0IGV2aWN0aW5n IEFSQyBjYWNoZSB3aGVuIGZyZWUNCisgICogcGFnZXMgZmFsbCBiZWxvdyAyNSUgb2YgaW5zdGFs bGVkIFJBTS4gIFRoaXMgbWFwcyByZWFzb25hYmx5IHdlbGwgdG8gaG93DQorICAqIFNvbGFyaXMg aXMgZG9jdW1lbnRlZCB0byBiZWhhdmU7IHdoZW4gImxvdHNmcmVlIiBpcyBpbnZhZGVkIFpGUyBp cyB0b2xkIA0KKyAgKiB0byBwYXJlIGRvd24uDQorICAqDQorICAqIFRoZSBwcm9ibGVtIGlzIHRo YXQgb24gRnJlZUJTRCBtYWNoaW5lcyB0aGUgc3lzdGVtIGRvZXNuJ3QgYXBwZWFyIHRvIGJlIA0K KyAgKiBnZXR0aW5nIHdoYXQgdGhlIGF1dGhvcnMgb2YgdGhlIG9yaWdpbmFsIGNvZGUgdGhvdWdo dCB0aGV5IHdlcmUgbG9va2luZyBhdA0KKyAgKiB3aXRoIGl0cyB0ZXN0IC0tIG9yIGF0IGxlYXN0 IG5vdCB3aGF0IFNvbGFyaXMgZGlkIC0tIGFuZCBhcyBhIHJlc3VsdCB0aGF0IA0KKyAgKiB0ZXN0 IG5ldmVyIHRyaWdnZXJzLiAgVGhhdCBsZWF2ZXMgdGhlIG9ubHkgcmVjbGFpbSB0cmlnZ2VyIGFz IHRoZSAicGFnaW5nIA0KKyAgKiBuZWVkZWQiIHN0YXR1cyBmbGFnLCBhbmQgYnkgdGhlIHRpbWUg KiB0aGF0IHRyaXBzIHRoZSBzeXN0ZW0gaXMgYWxyZWFkeSANCisgICogaW4gbG93LW1lbW9yeSB0 cm91YmxlLiAgVGhpcyBjYW4gbGVhZCB0byBzZXZlcmUgcGF0aG9sb2dpY2FsIGJlaGF2aW9yIA0K KyAgKiB1bmRlciB0aGUgZm9sbG93aW5nIHNjZW5hcmlvOg0KKyAgKiAtIFRoZSBzeXN0ZW0gc3Rh cnRzIHRvIHBhZ2UgYW5kIEFSQyBpcyBldmljdGVkLg0KKyAgKiAtIFRoZSBzeXN0ZW0gc3RvcHMg cGFnaW5nIGFzIEFSQydzIGV2aWN0aW9uIGRyb3BzIHdpcmVkIFJBTSBhIGJpdC4NCisgICogLSBB UkMgc3RhcnRzIGluY3JlYXNpbmcgaXRzIGFsbG9jYXRpb24gYWdhaW4sIGFuZCB3aXJlZCBtZW1v cnkgZ3Jvd3MuDQorICAqIC0gQSBuZXcgaW1hZ2UgaXMgYWN0aXZhdGVkLCBhbmQgdGhlIHN5c3Rl bSBvbmNlIGFnYWluIGF0dGVtcHRzIHRvIHBhZ2UuDQorICAqIC0gQVJDIHN0YXJ0cyB0byBiZSBl dmljdGVkIGFnYWluLg0KKyAgKiAtIEJhY2sgdG8gIzINCisgICogDQorICAqIE5vdGUgdGhhdCBa RlMncyBBUkMgZGVmYXVsdCAodW5sZXNzIHlvdSBvdmVycmlkZSBpdCBpbiAvYm9vdC9sb2FkZXIu Y29uZikNCisgICogaXMgdG8gYWxsb3cgdGhlIEFSQyBjYWNoZSB0byBncmFiIG5lYXJseSBhbGwg b2YgZnJlZSBSQU0sIHByb3ZpZGVkIG5vYm9keQ0KKyAgKiBlbHNlIG5lZWRzIGl0LiAgVGhhdCB3 b3VsZCBiZSBvayBpZiB3ZSBldmljdGVkIGNhY2hlIHdoZW4gcmVxdWlyZWQuDQorICAqIA0KKyAg KiBVbmZvcnR1bmF0ZWx5IHRoZSBzeXN0ZW0gY2FuIGdldCBpbnRvIGEgc3RhdGUgd2hlcmUgaXQg bmV2ZXINCisgICogbWFuYWdlcyB0byBwYWdlIGFueXRoaW5nIG9mIG1hdGVyaWFsaXR5IGJhY2sg aW4sIGFzIGlmIHRoZXJlIGlzIGFjdGl2ZQ0KKyAgKiBJL08gdGhlIEFSQyB3aWxsIHN0YXJ0IGdy YWJiaW5nIHNwYWNlIG9uY2UgYWdhaW4gYXMgc29vbiBhcyB0aGUgbWVtb3J5IA0KKyAgKiBjb250 ZW50aW9uIHN0YXRlIGRyb3BzLiAgRm9yIHRoaXMgcmVhc29uIHRoZSAicGFnaW5nIGlzIG9jY3Vy cmluZyIgZmxhZyANCisgICogc2hvdWxkIGJlIHRoZSAqKmxhc3QgcmVzb3J0KiogY29uZGl0aW9u IGZvciBBUkMgZXZpY3Rpb247IHlvdSB3YW50IHRvIA0KKyAgKiAoYXMgU29sYXJpcyBkb2VzKSBz dGFydCB3aGVuIHRoZXJlIGlzIG1hdGVyaWFsIGZyZWUgUkFNIGxlZnQgQlVUIHRoZQ0KKyAgKiB2 bSBzeXN0ZW0gdGhpbmtzIGl0IG5lZWRzIHRvIGJlIGFjdGl2ZSB0byBzdGVhbCBwYWdlcyBiYWNr IGluIHRoZSBhdHRlbXB0DQorICAqIHRvIG5ldmVyIGdldCBpbnRvIHRoZSBjb25kaXRpb24gd2hl cmUgeW91J3JlIHBvdGVudGlhbGx5IHBhZ2luZyBvZmYgDQorICAqIGV4ZWN1dGFibGVzIGluIGZh dm9yIG9mIGxlYXZpbmcgZGlzayBjYWNoZSBhbGxvY2F0ZWQuDQorICAqDQorICAqIFRvIGZpeCB0 aGlzIHdlIGNoYW5nZSBob3cgd2UgbG9vayBhdCBsb3cgbWVtb3J5LCBkZWNsYXJpbmcgdHdvIG5l dw0KKyAgKiBydW50aW1lIHR1bmFibGVzIGFuZCBvbmUgc3RhdHVzLg0KKyAgKiANCisgICogVGhl IG5ldyBzeXNjdGxzIGFyZToNCisgICogdmZzLnpmcy5hcmNfZnJlZXBhZ2VzIChmcmVlIHBhZ2Vz IHJlcXVpcmVkIHRvIGNhbGwgUkFNICJzdWZmaWNpZW50IikNCisgICogdmZzLnpmcy5hcmNfZnJl ZXBhZ2VfcGVyY2VudCAoYWRkaXRpb25hbCByZXNlcnZhdGlvbiBwZXJjZW50YWdlLCBkZWZhdWx0 IDApDQorICAqIHZmcy56ZnMuYXJjX3Nocmlua19uZWVkZWQgKHNob3dzICIxIiBpZiB3ZSdyZSBh c2tpbmcgZm9yIHNocmlua2luZyB0aGUgQVJDKQ0KKyAgKiANCisgICogdmZzLnpmcy5hcmNfZnJl ZXBhZ2VzIGlzIGluaXRpYWxpemVkIGZyb20gdm0udl9mcmVlX3RhcmdldC4NCisgICogVGhpcyBz aG91bGQgaW5zdXJlIHRoYXQgd2UgYWxsb3cgdGhlIFZNIHN5c3RlbSB0byBzdGVhbCBwYWdlcywN CisgICogYnV0IHBhcmUgdGhlIGNhY2hlIGJlZm9yZSB3ZSBzdXNwZW5kIHByb2Nlc3NlcyBhdHRl bXB0aW5nIHRvIGdldCBtb3JlDQorICAqIG1lbW9yeSwgdGhlcmVieSBhdm9pZGluZyAic3RhbGxz LiIgIFlvdSBjYW4gc2V0IHRoaXMgaGlnaGVyIGlmIHlvdSB3aXNoLA0KKyAgKiBvciBmb3JjZSBh IHNwZWNpZmljIHBlcmNlbnRhZ2UgcmVzZXJ2YXRpb24gYXMgd2VsbCwgYnV0IGRvaW5nIHNvIG1h eQ0KKyAgKiBjYXVzZSB0aGUgY2FjaGUgdG8gcGFyZSBiYWNrIHdoaWxlIHRoZSBWTSBzeXN0ZW0g cmVtYWlucyB3aWxsaW5nIHRvDQorICAqIGFsbG93ICJpbmFjdGl2ZSIgcGFnZXMgdG8gYWNjdW11 bGF0ZS4gIFRoZSBjaGFsbGVuZ2UgaXMgdGhhdCBpbWFnZQ0KKyAgKiBhY3RpdmF0aW9uIGNhbiBm b3JjZSB0aGluZ3MgaW50byB0aGUgcGFnZSBzcGFjZSBvbiBhIHJlcGVhdGVkIGJhc2lzDQorICAq IGlmIHlvdSBhbGxvdyB0aGlzIGxldmVsIHRvIGJlIHRvbyBzbWFsbCAodGhlIGFib3ZlIHBhdGhv bG9naWNhbA0KKyAgKiBiZWhhdmlvcik7IHRoZSBkZWZhdWx0cyBzaG91bGQgYXZvaWQgdGhhdCBi ZWhhdmlvciBidXQgdGhlIHN5c2N0bHMgDQorICAqIGFyZSBleHBvc2VkIHNob3VsZCB5b3VyIHdv cmtsb2FkIHJlcXVpcmUgYWRqdXN0bWVudC4NCisgICoNCisgICogSWYgd2UncmUgdXNpbmcgdGhp cyBjaGVjayBmb3IgbG93IG1lbW9yeSB3ZSBhcmUgcmVwbGFjaW5nIHRoZSBwcmV2aW91cw0KKyAg KiBvbmVzLCBpbmNsdWRpbmcgdGhlIG9kZGJhbGwgInJhbmRvbSIgcmVjbGFpbSB0aGF0IGFwcGVh cnMgdG8gZmlyZSBmYXINCisgICogbW9yZSBvZnRlbiB0aGFuIGl0IHNob3VsZC4gIFdlIHN0aWxs IHRyaWdnZXIgaWYgdGhlIHN5c3RlbSBwYWdlcy4NCisgICoNCisgICogSWYgeW91IHR1cm4gb24g TkVXUkVDTEFJTV9ERUJVRyB0aGVuIHRoZSBrZXJuZWwgd2lsbCBwcmludCBvbiB0aGUgY29uc29s ZQ0KKyAgKiBzdGF0dXMgbWVzc2FnZXMgd2hlbiB0aGUgcmVjbGFpbSBzdGF0dXMgdHJpcHMgb24g YW5kIG9mZiwgYWxvbmcgd2l0aCB0aGUNCisgICogcGFnZSBjb3VudCBhZ2dyZWdhdGUgdGhhdCB0 cmlnZ2VyZWQgaXQgKGFuZCB0aGUgZnJlZSBzcGFjZSkgZm9yIGVhY2gNCisgICogZXZlbnQuIA0K KyAgKi8NCisgDQorICNkZWZpbmUJTkVXUkVDTEFJTQ0KKyAjdW5kZWYJTkVXUkVDTEFJTV9ERUJV Rw0KKyANCisgDQogIC8qDQogICAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAxMCwgT3JhY2xlIGFu ZC9vciBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4NCiAgICogQ29weXJpZ2h0 IChjKSAyMDEzIGJ5IERlbHBoaXguIEFsbCByaWdodHMgcmVzZXJ2ZWQuDQoqKioqKioqKioqKioq KioNCioqKiAxMzksMTQ0ICoqKioNCi0tLSAyMTEsMjMwIC0tLS0NCiAgDQogICNpbmNsdWRlIDx2 bS92bV9wYWdlb3V0Lmg+DQogIA0KKyAjaWZkZWYJTkVXUkVDTEFJTQ0KKyAjaWZkZWYJX19GcmVl QlNEX18NCisgI2luY2x1ZGUgPHN5cy9zeXNjdGwuaD4NCisgI2luY2x1ZGUgPHN5cy92bW1ldGVy Lmg+DQorIC8qDQorICAqIFN0cnVjdCBjbnQuIHdhcyByZW5hbWVkIGluIC1oZWFkICgxMS1jdXJy ZW50KSBhdCByZXYgMTEwMDE2OyBjaGVjayBmb3IgaXQNCisgICovDQorICNpZiBfX0ZyZWVCU0Rf dmVyc2lvbiA8IDExMDAwMTYNCisgI2RlZmluZQl2bV9jbnQJY250DQorICNlbmRpZgkvKiBfX0Zy ZWVCU0RfdmVyc2lvbiAqLw0KKyANCisgI2VuZGlmCS8qIF9fRnJlZUJTRF9fICovDQorICNlbmRp ZgkvKiBORVdSRUNMQUlNICovDQorIA0KICAjaWZkZWYgaWxsdW1vcw0KICAjaWZuZGVmIF9LRVJO RUwNCiAgLyogc2V0IHdpdGggWkZTX0RFQlVHPXdhdGNoLCB0byBlbmFibGUgd2F0Y2hwb2ludHMg b24gZnJvemVuIGJ1ZmZlcnMgKi8NCioqKioqKioqKioqKioqKg0KKioqIDIwMywyMTggKioqKg0K LS0tIDI4OSwzMjcgLS0tLQ0KICBpbnQgemZzX2FyY19zaHJpbmtfc2hpZnQgPSAwOw0KICBpbnQg emZzX2FyY19wX21pbl9zaGlmdCA9IDA7DQogIGludCB6ZnNfZGlzYWJsZV9kdXBfZXZpY3Rpb24g PSAwOw0KKyAjaWZkZWYJTkVXUkVDTEFJTQ0KKyAjaWZkZWYgIF9fRnJlZUJTRF9fDQorIHN0YXRp YwlpbnQgZnJlZXBhZ2VzID0gMDsJLyogVGhpcyBtdWNoIG1lbW9yeSBpcyBjb25zaWRlcmVkIGNy aXRpY2FsICovDQorIHN0YXRpYwlpbnQgcGVyY2VudF90YXJnZXQgPSAwOwkvKiBBZGRpdGlvbmFs bHkgcmVzZXJ2ZSAiWCIgcGVyY2VudCBmcmVlIFJBTSAqLw0KKyBzdGF0aWMJaW50IHNocmlua19u ZWVkZWQgPSAwOwkvKiBTaHJpbmthZ2Ugb2YgQVJDIGNhY2hlIG5lZWRlZD8JKi8NCisgI2VuZGlm CS8qIF9fRnJlZUJTRF9fICovDQorICNlbmRpZgkvKiBORVdSRUNMQUlNICovDQogIA0KICBUVU5B QkxFX1FVQUQoInZmcy56ZnMuYXJjX21heCIsICZ6ZnNfYXJjX21heCk7DQogIFRVTkFCTEVfUVVB RCgidmZzLnpmcy5hcmNfbWluIiwgJnpmc19hcmNfbWluKTsNCiAgVFVOQUJMRV9RVUFEKCJ2ZnMu emZzLmFyY19tZXRhX2xpbWl0IiwgJnpmc19hcmNfbWV0YV9saW1pdCk7DQorICNpZmRlZglORVdS RUNMQUlNDQorICNpZmRlZiAgX19GcmVlQlNEX18NCisgVFVOQUJMRV9JTlQoInZmcy56ZnMuYXJj X2ZyZWVwYWdlcyIsICZmcmVlcGFnZXMpOw0KKyBUVU5BQkxFX0lOVCgidmZzLnpmcy5hcmNfZnJl ZXBhZ2VfcGVyY2VudCIsICZwZXJjZW50X3RhcmdldCk7DQorIFRVTkFCTEVfSU5UKCJ2ZnMuemZz LmFyY19zaHJpbmtfbmVlZGVkIiwgJnNocmlua19uZWVkZWQpOw0KKyAjZW5kaWYJLyogX19GcmVl QlNEX18gKi8NCisgI2VuZGlmCS8qIE5FV1JFQ0xBSU0gKi8NCisgDQogIFNZU0NUTF9ERUNMKF92 ZnNfemZzKTsNCiAgU1lTQ1RMX1VRVUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX21heCwgQ1RM RkxBR19SRFRVTiwgJnpmc19hcmNfbWF4LCAwLA0KICAgICAgIk1heGltdW0gQVJDIHNpemUiKTsN CiAgU1lTQ1RMX1VRVUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX21pbiwgQ1RMRkxBR19SRFRV TiwgJnpmc19hcmNfbWluLCAwLA0KICAgICAgIk1pbmltdW0gQVJDIHNpemUiKTsNCiAgDQorICNp ZmRlZglORVdSRUNMQUlNDQorICNpZmRlZiAgX19GcmVlQlNEX18NCisgU1lTQ1RMX0lOVChfdmZz X3pmcywgT0lEX0FVVE8sIGFyY19mcmVlcGFnZXMsIENUTEZMQUdfUldUVU4sICZmcmVlcGFnZXMs IDAsICJBUkMgRnJlZSBSQU0gUGFnZXMgUmVxdWlyZWQiKTsNCisgU1lTQ1RMX0lOVChfdmZzX3pm cywgT0lEX0FVVE8sIGFyY19mcmVlcGFnZV9wZXJjZW50LCBDVExGTEFHX1JXVFVOLCAmcGVyY2Vu dF90YXJnZXQsIDAsICJBUkMgRnJlZSBSQU0gVGFyZ2V0IHBlcmNlbnRhZ2UiKTsNCisgU1lTQ1RM X0lOVChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19zaHJpbmtfbmVlZGVkLCBDVExGTEFHX1JELCAm c2hyaW5rX25lZWRlZCwgMCwgIkFSQyBNZW1vcnkgQ29uc3RyYWluZWQgKDAgPSBubywgMSA9IHll cykiKTsNCisgI2VuZGlmCS8qIF9fRnJlZUJTRF9fICovDQorICNlbmRpZgkvKiBORVdSRUNMQUlN ICovDQorIA0KICAvKg0KICAgKiBOb3RlIHRoYXQgYnVmZmVycyBjYW4gYmUgaW4gb25lIG9mIDYg c3RhdGVzOg0KICAgKglBUkNfYW5vbgktIGFub255bW91cyAoZGlzY3Vzc2VkIGJlbG93KQ0KKioq KioqKioqKioqKioqDQoqKiogMjQzOCwyNDQzICoqKioNCi0tLSAyNTQ3LDI1NTcgLS0tLQ0KICB7 DQogIA0KICAjaWZkZWYgX0tFUk5FTA0KKyAjaWZkZWYJTkVXUkVDTEFJTV9ERUJVRw0KKyAJc3Rh dGljCWludAl4dmFsID0gLTE7DQorIAlzdGF0aWMJaW50CW9sZHBlcmNlbnQgPSAwOw0KKyAJc3Rh dGljCWludAlvbGRmcmVlcGFnZXMgPSAwOw0KKyAjZW5kaWYJLyogTkVXUkVDTEFJTV9ERUJVRyAq Lw0KICANCiAgCWlmIChuZWVkZnJlZSkNCiAgCQlyZXR1cm4gKDEpOw0KKioqKioqKioqKioqKioq DQoqKiogMjQ3NiwyNDgxICoqKioNCi0tLSAyNTkwLDI1OTYgLS0tLQ0KICAJCXJldHVybiAoMSk7 DQogIA0KICAjaWYgZGVmaW5lZChfX2kzODYpDQorIA0KICAJLyoNCiAgCSAqIElmIHdlJ3JlIG9u IGFuIGkzODYgcGxhdGZvcm0sIGl0J3MgcG9zc2libGUgdGhhdCB3ZSdsbCBleGhhdXN0IHRoZQ0K ICAJICoga2VybmVsIGhlYXAgc3BhY2UgYmVmb3JlIHdlIGV2ZXIgcnVuIG91dCBvZiBhdmFpbGFi bGUgcGh5c2ljYWwNCioqKioqKioqKioqKioqKg0KKioqIDI0OTIsMjUwMiAqKioqDQogIAkJcmV0 dXJuICgxKTsNCiAgI2VuZGlmDQogICNlbHNlCS8qICFzdW4gKi8NCiAgCWlmIChrbWVtX3VzZWQo KSA+IChrbWVtX3NpemUoKSAqIDMpIC8gNCkNCiAgCQlyZXR1cm4gKDEpOw0KICAjZW5kaWYJLyog c3VuICovDQogIA0KLSAjZWxzZQ0KICAJaWYgKHNwYV9nZXRfcmFuZG9tKDEwMCkgPT0gMCkNCiAg CQlyZXR1cm4gKDEpOw0KICAjZW5kaWYNCi0tLSAyNjA3LDI2NzEgLS0tLQ0KICAJCXJldHVybiAo MSk7DQogICNlbmRpZg0KICAjZWxzZQkvKiAhc3VuICovDQorIA0KKyAjaWZkZWYJTkVXUkVDTEFJ TQ0KKyAjaWZkZWYgIF9fRnJlZUJTRF9fDQorIC8qDQorICAqIEltcGxlbWVudCB0aGUgbmV3IHR1 bmFibGUgZnJlZSBSQU0gYWxnb3JpdGhtLiAgV2UgY2hlY2sgdGhlIGZyZWUgcGFnZXMNCisgICog YWdhaW5zdCB0aGUgbWluaW11bSBzcGVjaWZpZWQgdGFyZ2V0IGFuZCB0aGUgcGVyY2VudGFnZSB0 aGF0IHNob3VsZCBiZQ0KKyAgKiBmcmVlLiAgSWYgd2UncmUgbG93IHdlIGFzayBmb3IgQVJDIGNh Y2hlIHNocmlua2FnZS4gIElmIHRoaXMgaXMgZGVmaW5lZCANCisgICogb24gYSBGcmVlQlNEIHN5 c3RlbSB0aGUgb2xkZXIgY2hlY2tzIGFyZSBub3QgcGVyZm9ybWVkLg0KKyAgKg0KKyAgKiBDaGVj ayBmaXJzdCB0byBzZWUgaWYgd2UgbmVlZCB0byBpbml0IGZyZWVwYWdlcywgdGhlbiB0ZXN0Lg0K KyAgKi8NCisgCWlmICghZnJlZXBhZ2VzKSB7CQkvKiBJZiB6ZXJvIHRoZW4gKHJlKWluaXQgKi8N CisgCQlmcmVlcGFnZXMgPSB2bV9jbnQudl9mcmVlX3RhcmdldDsNCisgI2lmZGVmCU5FV1JFQ0xB SU1fREVCVUcNCisgCQlwcmludGYoIlpGUyBBUkM6IERlZmF1bHQgdmZzLnpmcy5hcmNfZnJlZXBh Z2VzIHRvIFsldV1cbiIsIGZyZWVwYWdlcyk7DQorICNlbmRpZgkvKiBORVdSRUNMQUlNX0RFQlVH ICovDQorIAl9DQorICNpZmRlZglORVdSRUNMQUlNX0RFQlVHDQorIAlpZiAocGVyY2VudF90YXJn ZXQgIT0gb2xkcGVyY2VudCkgew0KKyAJCXByaW50ZigiWkZTIEFSQzogUmVzZXJ2YXRpb24gcGVy Y2VudCBjaGFuZ2UgdG8gWyVkXSwgWyVkXSBwYWdlcywgWyVkXSBmcmVlXG4iLCBwZXJjZW50X3Rh cmdldCwgdm1fY250LnZfcGFnZV9jb3VudCwgdm1fY250LnZfZnJlZV9jb3VudCk7DQorIAkJb2xk cGVyY2VudCA9IHBlcmNlbnRfdGFyZ2V0Ow0KKyAJfQ0KKyAJaWYgKGZyZWVwYWdlcyAhPSBvbGRm cmVlcGFnZXMpIHsNCisgCQlwcmludGYoIlpGUyBBUkM6IExvdyBSQU0gcGFnZSBjaGFuZ2UgdG8g WyVkXSwgWyVkXSBwYWdlcywgWyVkXSBmcmVlXG4iLCBmcmVlcGFnZXMsIHZtX2NudC52X3BhZ2Vf Y291bnQsIHZtX2NudC52X2ZyZWVfY291bnQpOw0KKyAJCW9sZGZyZWVwYWdlcyA9IGZyZWVwYWdl czsNCisgCX0NCisgI2VuZGlmCS8qIE5FV1JFQ0xBSU1fREVCVUcgKi8NCisgLyoNCisgICogTm93 IGZpZ3VyZSBvdXQgaG93IG11Y2ggZnJlZSBSQU0gd2UgcmVxdWlyZSB0byBjYWxsIHRoZSBBUkMg Y2FjaGUgc3RhdHVzDQorICAqICJvayIuICBBZGQgdGhlIHBlcmNlbnRhZ2Ugc3BlY2lmaWVkIG9m IHRoZSB0b3RhbCB0byB0aGUgYmFzZSByZXF1aXJlbWVudC4NCisgICovDQorIA0KKyAJaWYgKHZt X2NudC52X2ZyZWVfY291bnQgPCAoZnJlZXBhZ2VzICsgKCh2bV9jbnQudl9wYWdlX2NvdW50IC8g MTAwKSAqIHBlcmNlbnRfdGFyZ2V0KSkpIHsNCisgI2lmZGVmCU5FV1JFQ0xBSU1fREVCVUcNCisg CQlpZiAoeHZhbCAhPSAxKSB7DQorIAkJCXByaW50ZigiWkZTIEFSQzogUkVDTEFJTSB0b3RhbCAl dSwgZnJlZSAldSwgZnJlZSBwY3QgKCV1KSwgcmVzZXJ2ZWQgKCV1KSwgdGFyZ2V0IHBjdCAoJXUp XG4iLCB2bV9jbnQudl9wYWdlX2NvdW50LCB2bV9jbnQudl9mcmVlX2NvdW50LCAoKHZtX2NudC52 X2ZyZWVfY291bnQgKiAxMDApIC8gdm1fY250LnZfcGFnZV9jb3VudCksIGZyZWVwYWdlcywgcGVy Y2VudF90YXJnZXQpOw0KKyAJCQl4dmFsID0gMTsNCisgCQl9DQorICNlbmRpZgkvKiBORVdSRUNM QUlNX0RFQlVHICovDQorIAkJc2hyaW5rX25lZWRlZCA9IDE7DQorIAkJcmV0dXJuKDEpOw0KKyAJ fSBlbHNlIHsNCisgI2lmZGVmCU5FV1JFQ0xBSU1fREVCVUcNCisgCQlpZiAoeHZhbCAhPSAwKSB7 DQorIAkJCXByaW50ZigiWkZTIEFSQzogTk9STUFMIHRvdGFsICV1LCBmcmVlICV1LCBmcmVlIHBj dCAoJXUpLCByZXNlcnZlZCAoJXUpLCB0YXJnZXQgcGN0ICgldSlcbiIsIHZtX2NudC52X3BhZ2Vf Y291bnQsIHZtX2NudC52X2ZyZWVfY291bnQsICgodm1fY250LnZfZnJlZV9jb3VudCAqIDEwMCkg LyB2bV9jbnQudl9wYWdlX2NvdW50KSwgZnJlZXBhZ2VzLCBwZXJjZW50X3RhcmdldCk7DQorIAkJ CXh2YWwgPSAwOw0KKyAJCX0NCisgI2VuZGlmCS8qIE5FV1JFQ0xBSU1fREVCVUcgKi8NCisgCQlz aHJpbmtfbmVlZGVkID0gMDsNCisgCQlyZXR1cm4oMCk7DQorIAl9DQorIA0KKyAjZW5kaWYJLyog X19GcmVlQlNEX18gKi8NCisgI2VuZGlmCS8qIE5FV1JFQ0xBSU0gKi8NCisgDQogIAlpZiAoa21l bV91c2VkKCkgPiAoa21lbV9zaXplKCkgKiAzKSAvIDQpDQogIAkJcmV0dXJuICgxKTsNCiAgI2Vu ZGlmCS8qIHN1biAqLw0KICANCiAgCWlmIChzcGFfZ2V0X3JhbmRvbSgxMDApID09IDApDQogIAkJ cmV0dXJuICgxKTsNCiAgI2VuZGlm 146287 2014-08-26 02:48:41 +0000 2014-09-13 05:25:58 +0000 ARC refactor patch less percentage reservation patch text/plain 8800 karl KioqIGFyYy5jLm9yaWcJU3VuIE1hciAyMyAxNDo1NTozMCAyMDE0Ci0tLSBhcmMuYwlNb24gQXVn IDI1IDIxOjI4OjE0IDIwMTQKKioqKioqKioqKioqKioqCioqKiAxOCwyMyAqKioqCi0tLSAxOCw5 MyAtLS0tCiAgICoKICAgKiBDRERMIEhFQURFUiBFTkQKICAgKi8KKyAKKyAvKiBLYXJsIERlbm5p bmdlciAoa2FybEBkZW5uaW5nZXIubmV0KSwgOC8yNS8yMDE0LCBGcmVlQlNELXNwZWNpZmljCisg ICogCisgICogSWYgIk5FV1JFQ0xBSU0iIGlzIGRlZmluZWQsIGNoYW5nZSB0aGUgImxvdyBtZW1v cnkiIHdhcm5pbmcgdGhhdCBjYXVzZXMKKyAgKiB0aGUgQVJDIGNhY2hlIHRvIGJlIHBhcmVkIGRv d24uICBUaGUgcmVhc29uIGZvciB0aGUgY2hhbmdlIGlzIHRoYXQgdGhlCisgICogYXBwYXJlbnQg YXR0ZW1wdGVkIGFsZ29yaXRobSBpcyB0byBzdGFydCBldmljdGluZyBBUkMgY2FjaGUgd2hlbiBm cmVlCisgICogcGFnZXMgZmFsbCBiZWxvdyAyNSUgb2YgaW5zdGFsbGVkIFJBTS4gIFRoaXMgbWFw cyByZWFzb25hYmx5IHdlbGwgdG8gaG93CisgICogU29sYXJpcyBpcyBkb2N1bWVudGVkIHRvIGJl aGF2ZTsgd2hlbiAibG90c2ZyZWUiIGlzIGludmFkZWQgWkZTIGlzIHRvbGQgCisgICogdG8gcGFy ZSBkb3duLgorICAqCisgICogVGhlIHByb2JsZW0gaXMgdGhhdCBvbiBGcmVlQlNEIG1hY2hpbmVz IHRoZSBzeXN0ZW0gZG9lc24ndCBhcHBlYXIgdG8gYmUgCisgICogZ2V0dGluZyB3aGF0IHRoZSBh dXRob3JzIG9mIHRoZSBvcmlnaW5hbCBjb2RlIHRob3VnaHQgdGhleSB3ZXJlIGxvb2tpbmcgYXQK KyAgKiB3aXRoIGl0cyB0ZXN0IC0tIG9yIGF0IGxlYXN0IG5vdCB3aGF0IFNvbGFyaXMgZGlkIC0t IGFuZCBhcyBhIHJlc3VsdCB0aGF0IAorICAqIHRlc3QgbmV2ZXIgdHJpZ2dlcnMuICBUaGF0IGxl YXZlcyB0aGUgb25seSByZWNsYWltIHRyaWdnZXIgYXMgdGhlICJwYWdpbmcgCisgICogbmVlZGVk IiBzdGF0dXMgZmxhZywgYW5kIGJ5IHRoZSB0aW1lICogdGhhdCB0cmlwcyB0aGUgc3lzdGVtIGlz IGFscmVhZHkgCisgICogaW4gbG93LW1lbW9yeSB0cm91YmxlLiAgVGhpcyBjYW4gbGVhZCB0byBz ZXZlcmUgcGF0aG9sb2dpY2FsIGJlaGF2aW9yIAorICAqIHVuZGVyIHRoZSBmb2xsb3dpbmcgc2Nl bmFyaW86CisgICogLSBUaGUgc3lzdGVtIHN0YXJ0cyB0byBwYWdlIGFuZCBBUkMgaXMgZXZpY3Rl ZC4KKyAgKiAtIFRoZSBzeXN0ZW0gc3RvcHMgcGFnaW5nIGFzIEFSQydzIGV2aWN0aW9uIGRyb3Bz IHdpcmVkIFJBTSBhIGJpdC4KKyAgKiAtIEFSQyBzdGFydHMgaW5jcmVhc2luZyBpdHMgYWxsb2Nh dGlvbiBhZ2FpbiwgYW5kIHdpcmVkIG1lbW9yeSBncm93cy4KKyAgKiAtIEEgbmV3IGltYWdlIGlz IGFjdGl2YXRlZCwgYW5kIHRoZSBzeXN0ZW0gb25jZSBhZ2FpbiBhdHRlbXB0cyB0byBwYWdlLgor ICAqIC0gQVJDIHN0YXJ0cyB0byBiZSBldmljdGVkIGFnYWluLgorICAqIC0gQmFjayB0byAjMgor ICAqIAorICAqIE5vdGUgdGhhdCBaRlMncyBBUkMgZGVmYXVsdCAodW5sZXNzIHlvdSBvdmVycmlk ZSBpdCBpbiAvYm9vdC9sb2FkZXIuY29uZikKKyAgKiBpcyB0byBhbGxvdyB0aGUgQVJDIGNhY2hl IHRvIGdyYWIgbmVhcmx5IGFsbCBvZiBmcmVlIFJBTSwgcHJvdmlkZWQgbm9ib2R5CisgICogZWxz ZSBuZWVkcyBpdC4gIFRoYXQgd291bGQgYmUgb2sgaWYgd2UgZXZpY3RlZCBjYWNoZSB3aGVuIHJl cXVpcmVkLgorICAqIAorICAqIFVuZm9ydHVuYXRlbHkgdGhlIHN5c3RlbSBjYW4gZ2V0IGludG8g YSBzdGF0ZSB3aGVyZSBpdCBuZXZlcgorICAqIG1hbmFnZXMgdG8gcGFnZSBhbnl0aGluZyBvZiBt YXRlcmlhbGl0eSBiYWNrIGluLCBhcyBpZiB0aGVyZSBpcyBhY3RpdmUKKyAgKiBJL08gdGhlIEFS QyB3aWxsIHN0YXJ0IGdyYWJiaW5nIHNwYWNlIG9uY2UgYWdhaW4gYXMgc29vbiBhcyB0aGUgbWVt b3J5IAorICAqIGNvbnRlbnRpb24gc3RhdGUgZHJvcHMuICBGb3IgdGhpcyByZWFzb24gdGhlICJw YWdpbmcgaXMgb2NjdXJyaW5nIiBmbGFnIAorICAqIHNob3VsZCBiZSB0aGUgKipsYXN0IHJlc29y dCoqIGNvbmRpdGlvbiBmb3IgQVJDIGV2aWN0aW9uOyB5b3Ugd2FudCB0byAKKyAgKiAoYXMgU29s YXJpcyBkb2VzKSBzdGFydCB3aGVuIHRoZXJlIGlzIG1hdGVyaWFsIGZyZWUgUkFNIGxlZnQgQlVU IHRoZQorICAqIHZtIHN5c3RlbSB0aGlua3MgaXQgbmVlZHMgdG8gYmUgYWN0aXZlIHRvIHN0ZWFs IHBhZ2VzIGJhY2sgaW4gdGhlIGF0dGVtcHQKKyAgKiB0byBuZXZlciBnZXQgaW50byB0aGUgY29u ZGl0aW9uIHdoZXJlIHlvdSdyZSBwb3RlbnRpYWxseSBwYWdpbmcgb2ZmIAorICAqIGV4ZWN1dGFi bGVzIGluIGZhdm9yIG9mIGxlYXZpbmcgZGlzayBjYWNoZSBhbGxvY2F0ZWQuCisgICoKKyAgKiBU byBmaXggdGhpcyB3ZSBjaGFuZ2UgaG93IHdlIGxvb2sgYXQgbG93IG1lbW9yeSwgZGVjbGFyaW5n IHR3byBuZXcKKyAgKiBydW50aW1lIHR1bmFibGVzIGFuZCBvbmUgc3RhdHVzLgorICAqIAorICAq IFRoZSBuZXcgc3lzY3RscyBhcmU6CisgICogdmZzLnpmcy5hcmNfZnJlZXBhZ2VzIChmcmVlIHBh Z2VzIHJlcXVpcmVkIHRvIGNhbGwgUkFNICJzdWZmaWNpZW50IikKKyAgKiB2ZnMuemZzLmFyY19z aHJpbmtfbmVlZGVkIChzaG93cyAiMSIgaWYgd2UncmUgYXNraW5nIGZvciBzaHJpbmtpbmcgdGhl IEFSQykKKyAgKiAKKyAgKiB2ZnMuemZzLmFyY19mcmVlcGFnZXMgaXMgaW5pdGlhbGl6ZWQgZnJv bSB2bS52X2ZyZWVfdGFyZ2V0LgorICAqIFRoaXMgc2hvdWxkIGluc3VyZSB0aGF0IHdlIGFsbG93 IHRoZSBWTSBzeXN0ZW0gdG8gc3RlYWwgcGFnZXMsCisgICogYnV0IHBhcmUgdGhlIGNhY2hlIGJl Zm9yZSB3ZSBzdXNwZW5kIHByb2Nlc3NlcyBhdHRlbXB0aW5nIHRvIGdldCBtb3JlCisgICogbWVt b3J5LCB0aGVyZWJ5IGF2b2lkaW5nICJzdGFsbHMuIiAgWW91IGNhbiBzZXQgdGhpcyBoaWdoZXIg aWYgeW91IHdpc2gsCisgICogYnV0IGRvaW5nIHNvIG1heSBjYXVzZSB0aGUgY2FjaGUgdG8gcGFy ZSBiYWNrIHdoaWxlIHRoZSBWTSBzeXN0ZW0gCisgICogcmVtYWlucyB3aWxsaW5nIHRvIGFsbG93 ICJpbmFjdGl2ZSIgcGFnZXMgdG8gYWNjdW11bGF0ZS4gIFRoZSBjaGFsbGVuZ2UgCisgICogaXMg dGhhdCBpbWFnZSBhY3RpdmF0aW9uIGNhbiBmb3JjZSB0aGluZ3MgaW50byB0aGUgcGFnZSBzcGFj ZSBvbiBhIAorICAqIHJlcGVhdGVkIGJhc2lzIGlmIHlvdSBhbGxvdyB0aGlzIGxldmVsIHRvIGJl IHRvbyBzbWFsbCAodGhlIGFib3ZlIAorICAqIHBhdGhvbG9naWNhbCBiZWhhdmlvcik7IHRoZSBk ZWZhdWx0cyBzaG91bGQgYXZvaWQgdGhhdCBiZWhhdmlvciBidXQgdGhlIAorICAqIHN5c2N0bCBp cyBleHBvc2VkIHNob3VsZCB5b3VyIHdvcmtsb2FkIHJlcXVpcmUgYWRqdXN0bWVudC4KKyAgKgor ICAqIElmIHdlJ3JlIHVzaW5nIHRoaXMgY2hlY2sgZm9yIGxvdyBtZW1vcnkgd2UgYXJlIHJlcGxh Y2luZyB0aGUgcHJldmlvdXMKKyAgKiBvbmVzLCBpbmNsdWRpbmcgdGhlIG9kZGJhbGwgInJhbmRv bSIgcmVjbGFpbSB0aGF0IGFwcGVhcnMgdG8gZmlyZSBmYXIKKyAgKiBtb3JlIG9mdGVuIHRoYW4g aXQgc2hvdWxkLiAgV2Ugc3RpbGwgdHJpZ2dlciBpZiB0aGUgc3lzdGVtIHBhZ2VzLgorICAqCisg ICogSWYgeW91IHR1cm4gb24gTkVXUkVDTEFJTV9ERUJVRyB0aGVuIHRoZSBrZXJuZWwgd2lsbCBw cmludCBvbiB0aGUgY29uc29sZQorICAqIHN0YXR1cyBtZXNzYWdlcyB3aGVuIHRoZSByZWNsYWlt IHN0YXR1cyB0cmlwcyBvbiBhbmQgb2ZmLCBhbG9uZyB3aXRoIHRoZQorICAqIHBhZ2UgY291bnQg YWdncmVnYXRlIHRoYXQgdHJpZ2dlcmVkIGl0IChhbmQgdGhlIGZyZWUgc3BhY2UpIGZvciBlYWNo CisgICogZXZlbnQuIAorICAqLworIAorICNkZWZpbmUJTkVXUkVDTEFJTQorICN1bmRlZglORVdS RUNMQUlNX0RFQlVHCisgCisgCiAgLyoKICAgKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMTAsIE9y YWNsZSBhbmQvb3IgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgICogQ29w eXJpZ2h0IChjKSAyMDEzIGJ5IERlbHBoaXguIEFsbCByaWdodHMgcmVzZXJ2ZWQuCioqKioqKioq KioqKioqKgoqKiogMTM5LDE0NCAqKioqCi0tLSAyMDksMjI4IC0tLS0KICAKICAjaW5jbHVkZSA8 dm0vdm1fcGFnZW91dC5oPgogIAorICNpZmRlZglORVdSRUNMQUlNCisgI2lmZGVmCV9fRnJlZUJT RF9fCisgI2luY2x1ZGUgPHN5cy9zeXNjdGwuaD4KKyAjaW5jbHVkZSA8c3lzL3ZtbWV0ZXIuaD4K KyAvKgorICAqIFN0cnVjdCBjbnQuIHdhcyByZW5hbWVkIGluIC1oZWFkICgxMS1jdXJyZW50KSBh dCByZXYgMTEwMDE2OyBjaGVjayBmb3IgaXQKKyAgKi8KKyAjaWYgX19GcmVlQlNEX3ZlcnNpb24g PCAxMTAwMDE2CisgI2RlZmluZQl2bV9jbnQJY250CisgI2VuZGlmCS8qIF9fRnJlZUJTRF92ZXJz aW9uICovCisgCisgI2VuZGlmCS8qIF9fRnJlZUJTRF9fICovCisgI2VuZGlmCS8qIE5FV1JFQ0xB SU0gKi8KKyAKICAjaWZkZWYgaWxsdW1vcwogICNpZm5kZWYgX0tFUk5FTAogIC8qIHNldCB3aXRo IFpGU19ERUJVRz13YXRjaCwgdG8gZW5hYmxlIHdhdGNocG9pbnRzIG9uIGZyb3plbiBidWZmZXJz ICovCioqKioqKioqKioqKioqKgoqKiogMjAzLDIxOCAqKioqCi0tLSAyODcsMzIyIC0tLS0KICBp bnQgemZzX2FyY19zaHJpbmtfc2hpZnQgPSAwOwogIGludCB6ZnNfYXJjX3BfbWluX3NoaWZ0ID0g MDsKICBpbnQgemZzX2Rpc2FibGVfZHVwX2V2aWN0aW9uID0gMDsKKyAjaWZkZWYJTkVXUkVDTEFJ TQorICNpZmRlZiAgX19GcmVlQlNEX18KKyBzdGF0aWMJaW50IGZyZWVwYWdlcyA9IDA7CS8qIFRo aXMgbXVjaCBtZW1vcnkgaXMgY29uc2lkZXJlZCBjcml0aWNhbCAqLworIHN0YXRpYwlpbnQgc2hy aW5rX25lZWRlZCA9IDA7CS8qIFNocmlua2FnZSBvZiBBUkMgY2FjaGUgbmVlZGVkPwkqLworICNl bmRpZgkvKiBfX0ZyZWVCU0RfXyAqLworICNlbmRpZgkvKiBORVdSRUNMQUlNICovCiAgCiAgVFVO QUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19tYXgiLCAmemZzX2FyY19tYXgpOwogIFRVTkFCTEVfUVVB RCgidmZzLnpmcy5hcmNfbWluIiwgJnpmc19hcmNfbWluKTsKICBUVU5BQkxFX1FVQUQoInZmcy56 ZnMuYXJjX21ldGFfbGltaXQiLCAmemZzX2FyY19tZXRhX2xpbWl0KTsKKyAjaWZkZWYJTkVXUkVD TEFJTQorICNpZmRlZiAgX19GcmVlQlNEX18KKyBUVU5BQkxFX0lOVCgidmZzLnpmcy5hcmNfZnJl ZXBhZ2VzIiwgJmZyZWVwYWdlcyk7CisgVFVOQUJMRV9JTlQoInZmcy56ZnMuYXJjX3Nocmlua19u ZWVkZWQiLCAmc2hyaW5rX25lZWRlZCk7CisgI2VuZGlmCS8qIF9fRnJlZUJTRF9fICovCisgI2Vu ZGlmCS8qIE5FV1JFQ0xBSU0gKi8KKyAKICBTWVNDVExfREVDTChfdmZzX3pmcyk7CiAgU1lTQ1RM X1VRVUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX21heCwgQ1RMRkxBR19SRFRVTiwgJnpmc19h cmNfbWF4LCAwLAogICAgICAiTWF4aW11bSBBUkMgc2l6ZSIpOwogIFNZU0NUTF9VUVVBRChfdmZz X3pmcywgT0lEX0FVVE8sIGFyY19taW4sIENUTEZMQUdfUkRUVU4sICZ6ZnNfYXJjX21pbiwgMCwK ICAgICAgIk1pbmltdW0gQVJDIHNpemUiKTsKICAKKyAjaWZkZWYJTkVXUkVDTEFJTQorICNpZmRl ZiAgX19GcmVlQlNEX18KKyBTWVNDVExfSU5UKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2ZyZWVw YWdlcywgQ1RMRkxBR19SV1RVTiwgJmZyZWVwYWdlcywgMCwgIkFSQyBGcmVlIFJBTSBQYWdlcyBS ZXF1aXJlZCIpOworIFNZU0NUTF9JTlQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfc2hyaW5rX25l ZWRlZCwgQ1RMRkxBR19SRCwgJnNocmlua19uZWVkZWQsIDAsICJBUkMgTWVtb3J5IENvbnN0cmFp bmVkICgwID0gbm8sIDEgPSB5ZXMpIik7CisgI2VuZGlmCS8qIF9fRnJlZUJTRF9fICovCisgI2Vu ZGlmCS8qIE5FV1JFQ0xBSU0gKi8KKyAKICAvKgogICAqIE5vdGUgdGhhdCBidWZmZXJzIGNhbiBi ZSBpbiBvbmUgb2YgNiBzdGF0ZXM6CiAgICoJQVJDX2Fub24JLSBhbm9ueW1vdXMgKGRpc2N1c3Nl ZCBiZWxvdykKKioqKioqKioqKioqKioqCioqKiAyNDM4LDI0NDMgKioqKgotLS0gMjU0MiwyNTUx IC0tLS0KICB7CiAgCiAgI2lmZGVmIF9LRVJORUwKKyAjaWZkZWYJTkVXUkVDTEFJTV9ERUJVRwor IAlzdGF0aWMJaW50CXh2YWwgPSAtMTsKKyAJc3RhdGljCWludAlvbGRmcmVlcGFnZXMgPSAwOwor ICNlbmRpZgkvKiBORVdSRUNMQUlNX0RFQlVHICovCiAgCiAgCWlmIChuZWVkZnJlZSkKICAJCXJl dHVybiAoMSk7CioqKioqKioqKioqKioqKgoqKiogMjQ3NiwyNDgxICoqKioKLS0tIDI1ODQsMjU5 MCAtLS0tCiAgCQlyZXR1cm4gKDEpOwogIAogICNpZiBkZWZpbmVkKF9faTM4NikKKyAKICAJLyoK ICAJICogSWYgd2UncmUgb24gYW4gaTM4NiBwbGF0Zm9ybSwgaXQncyBwb3NzaWJsZSB0aGF0IHdl J2xsIGV4aGF1c3QgdGhlCiAgCSAqIGtlcm5lbCBoZWFwIHNwYWNlIGJlZm9yZSB3ZSBldmVyIHJ1 biBvdXQgb2YgYXZhaWxhYmxlIHBoeXNpY2FsCioqKioqKioqKioqKioqKgoqKiogMjQ5MiwyNTAy ICoqKioKICAJCXJldHVybiAoMSk7CiAgI2VuZGlmCiAgI2Vsc2UJLyogIXN1biAqLwogIAlpZiAo a21lbV91c2VkKCkgPiAoa21lbV9zaXplKCkgKiAzKSAvIDQpCiAgCQlyZXR1cm4gKDEpOwogICNl bmRpZgkvKiBzdW4gKi8KICAKLSAjZWxzZQogIAlpZiAoc3BhX2dldF9yYW5kb20oMTAwKSA9PSAw KQogIAkJcmV0dXJuICgxKTsKICAjZW5kaWYKLS0tIDI2MDEsMjY2MSAtLS0tCiAgCQlyZXR1cm4g KDEpOwogICNlbmRpZgogICNlbHNlCS8qICFzdW4gKi8KKyAKKyAjaWZkZWYJTkVXUkVDTEFJTQor ICNpZmRlZiAgX19GcmVlQlNEX18KKyAvKgorICAqIEltcGxlbWVudCB0aGUgbmV3IHR1bmFibGUg ZnJlZSBSQU0gYWxnb3JpdGhtLiAgV2UgY2hlY2sgdGhlIGZyZWUgcGFnZXMKKyAgKiBhZ2FpbnN0 IHRoZSBtaW5pbXVtIHNwZWNpZmllZCB0YXJnZXQgYW5kIHRoZSBwZXJjZW50YWdlIHRoYXQgc2hv dWxkIGJlCisgICogZnJlZS4gIElmIHdlJ3JlIGxvdyB3ZSBhc2sgZm9yIEFSQyBjYWNoZSBzaHJp bmthZ2UuICBJZiB0aGlzIGlzIGRlZmluZWQgCisgICogb24gYSBGcmVlQlNEIHN5c3RlbSB0aGUg b2xkZXIgY2hlY2tzIGFyZSBub3QgcGVyZm9ybWVkLgorICAqCisgICogQ2hlY2sgZmlyc3QgdG8g c2VlIGlmIHdlIG5lZWQgdG8gaW5pdCBmcmVlcGFnZXMsIHRoZW4gdGVzdC4KKyAgKi8KKyAJaWYg KCFmcmVlcGFnZXMpIHsJCS8qIElmIHplcm8gdGhlbiAocmUpaW5pdCAqLworIAkJZnJlZXBhZ2Vz ID0gdm1fY250LnZfZnJlZV90YXJnZXQ7CisgI2lmZGVmCU5FV1JFQ0xBSU1fREVCVUcKKyAJCXBy aW50ZigiWkZTIEFSQzogRGVmYXVsdCB2ZnMuemZzLmFyY19mcmVlcGFnZXMgdG8gWyV1XVxuIiwg ZnJlZXBhZ2VzKTsKKyAjZW5kaWYJLyogTkVXUkVDTEFJTV9ERUJVRyAqLworIAl9CisgI2lmZGVm CU5FV1JFQ0xBSU1fREVCVUcKKyAJaWYgKGZyZWVwYWdlcyAhPSBvbGRmcmVlcGFnZXMpIHsKKyAJ CXByaW50ZigiWkZTIEFSQzogTG93IFJBTSBwYWdlIGNoYW5nZSB0byBbJWRdLCBbJWRdIHBhZ2Vz LCBbJWRdIGZyZWVcbiIsIGZyZWVwYWdlcywgdm1fY250LnZfcGFnZV9jb3VudCwgdm1fY250LnZf ZnJlZV9jb3VudCk7CisgCQlvbGRmcmVlcGFnZXMgPSBmcmVlcGFnZXM7CisgCX0KKyAjZW5kaWYJ LyogTkVXUkVDTEFJTV9ERUJVRyAqLworIC8qCisgICogTm93IGZpZ3VyZSBvdXQgaG93IG11Y2gg ZnJlZSBSQU0gd2UgcmVxdWlyZSB0byBjYWxsIHRoZSBBUkMgY2FjaGUgc3RhdHVzCisgICogIm9r Ii4gIEFkZCB0aGUgcGVyY2VudGFnZSBzcGVjaWZpZWQgb2YgdGhlIHRvdGFsIHRvIHRoZSBiYXNl IHJlcXVpcmVtZW50LgorICAqLworIAorIAlpZiAodm1fY250LnZfZnJlZV9jb3VudCA8IGZyZWVw YWdlcykgeworICNpZmRlZglORVdSRUNMQUlNX0RFQlVHCisgCQlpZiAoeHZhbCAhPSAxKSB7Cisg CQkJcHJpbnRmKCJaRlMgQVJDOiBSRUNMQUlNIHRvdGFsICV1LCBmcmVlICV1LCBmcmVlIHBjdCAo JXUpLCByZXNlcnZlZCAoJXUpXG4iLCB2bV9jbnQudl9wYWdlX2NvdW50LCB2bV9jbnQudl9mcmVl X2NvdW50LCAoKHZtX2NudC52X2ZyZWVfY291bnQgKiAxMDApIC8gdm1fY250LnZfcGFnZV9jb3Vu dCksIGZyZWVwYWdlcyk7CisgCQkJeHZhbCA9IDE7CisgCQl9CisgI2VuZGlmCS8qIE5FV1JFQ0xB SU1fREVCVUcgKi8KKyAJCXNocmlua19uZWVkZWQgPSAxOworIAkJcmV0dXJuKDEpOworIAl9IGVs c2UgeworICNpZmRlZglORVdSRUNMQUlNX0RFQlVHCisgCQlpZiAoeHZhbCAhPSAwKSB7CisgCQkJ cHJpbnRmKCJaRlMgQVJDOiBOT1JNQUwgdG90YWwgJXUsIGZyZWUgJXUsIGZyZWUgcGN0ICgldSks IHJlc2VydmVkICgldSlcbiIsIHZtX2NudC52X3BhZ2VfY291bnQsIHZtX2NudC52X2ZyZWVfY291 bnQsICgodm1fY250LnZfZnJlZV9jb3VudCAqIDEwMCkgLyB2bV9jbnQudl9wYWdlX2NvdW50KSwg ZnJlZXBhZ2VzKTsKKyAJCQl4dmFsID0gMDsKKyAJCX0KKyAjZW5kaWYJLyogTkVXUkVDTEFJTV9E RUJVRyAqLworIAkJc2hyaW5rX25lZWRlZCA9IDA7CisgCQlyZXR1cm4oMCk7CisgCX0KKyAKKyAj ZW5kaWYJLyogX19GcmVlQlNEX18gKi8KKyAjZW5kaWYJLyogTkVXUkVDTEFJTSAqLworIAogIAlp ZiAoa21lbV91c2VkKCkgPiAoa21lbV9zaXplKCkgKiAzKSAvIDQpCiAgCQlyZXR1cm4gKDEpOwog ICNlbmRpZgkvKiBzdW4gKi8KICAKICAJaWYgKHNwYV9nZXRfcmFuZG9tKDEwMCkgPT0gMCkKICAJ CXJldHVybiAoMSk7CiAgI2VuZGlmCg== 146300 2014-08-26 11:45:41 +0000 2015-10-04 11:51:18 +0000 ARC refactor patch less percentage reservation for after r269846 arc.20140826-after_r269846.patch text/plain 9078 junchoon KioqIGFyYy5jLm9yaWcJU3VuIE1hciAyMyAxNDo1NTozMCAyMDE0Ci0tLSBhcmMuYwlNb24gQXVn IDI1IDIxOjI4OjE0IDIwMTQKKioqKioqKioqKioqKioqCioqKiAxOCwyMyAqKioqCi0tLSAxOCw5 MyAtLS0tCiAgICoKICAgKiBDRERMIEhFQURFUiBFTkQKICAgKi8KKyAKKyAvKiBLYXJsIERlbm5p bmdlciAoa2FybEBkZW5uaW5nZXIubmV0KSwgOC8yNS8yMDE0LCBGcmVlQlNELXNwZWNpZmljCisg ICogCisgICogSWYgIk5FV1JFQ0xBSU0iIGlzIGRlZmluZWQsIGNoYW5nZSB0aGUgImxvdyBtZW1v cnkiIHdhcm5pbmcgdGhhdCBjYXVzZXMKKyAgKiB0aGUgQVJDIGNhY2hlIHRvIGJlIHBhcmVkIGRv d24uICBUaGUgcmVhc29uIGZvciB0aGUgY2hhbmdlIGlzIHRoYXQgdGhlCisgICogYXBwYXJlbnQg YXR0ZW1wdGVkIGFsZ29yaXRobSBpcyB0byBzdGFydCBldmljdGluZyBBUkMgY2FjaGUgd2hlbiBm cmVlCisgICogcGFnZXMgZmFsbCBiZWxvdyAyNSUgb2YgaW5zdGFsbGVkIFJBTS4gIFRoaXMgbWFw cyByZWFzb25hYmx5IHdlbGwgdG8gaG93CisgICogU29sYXJpcyBpcyBkb2N1bWVudGVkIHRvIGJl aGF2ZTsgd2hlbiAibG90c2ZyZWUiIGlzIGludmFkZWQgWkZTIGlzIHRvbGQgCisgICogdG8gcGFy ZSBkb3duLgorICAqCisgICogVGhlIHByb2JsZW0gaXMgdGhhdCBvbiBGcmVlQlNEIG1hY2hpbmVz IHRoZSBzeXN0ZW0gZG9lc24ndCBhcHBlYXIgdG8gYmUgCisgICogZ2V0dGluZyB3aGF0IHRoZSBh dXRob3JzIG9mIHRoZSBvcmlnaW5hbCBjb2RlIHRob3VnaHQgdGhleSB3ZXJlIGxvb2tpbmcgYXQK KyAgKiB3aXRoIGl0cyB0ZXN0IC0tIG9yIGF0IGxlYXN0IG5vdCB3aGF0IFNvbGFyaXMgZGlkIC0t IGFuZCBhcyBhIHJlc3VsdCB0aGF0IAorICAqIHRlc3QgbmV2ZXIgdHJpZ2dlcnMuICBUaGF0IGxl YXZlcyB0aGUgb25seSByZWNsYWltIHRyaWdnZXIgYXMgdGhlICJwYWdpbmcgCisgICogbmVlZGVk IiBzdGF0dXMgZmxhZywgYW5kIGJ5IHRoZSB0aW1lICogdGhhdCB0cmlwcyB0aGUgc3lzdGVtIGlz IGFscmVhZHkgCisgICogaW4gbG93LW1lbW9yeSB0cm91YmxlLiAgVGhpcyBjYW4gbGVhZCB0byBz ZXZlcmUgcGF0aG9sb2dpY2FsIGJlaGF2aW9yIAorICAqIHVuZGVyIHRoZSBmb2xsb3dpbmcgc2Nl bmFyaW86CisgICogLSBUaGUgc3lzdGVtIHN0YXJ0cyB0byBwYWdlIGFuZCBBUkMgaXMgZXZpY3Rl ZC4KKyAgKiAtIFRoZSBzeXN0ZW0gc3RvcHMgcGFnaW5nIGFzIEFSQydzIGV2aWN0aW9uIGRyb3Bz IHdpcmVkIFJBTSBhIGJpdC4KKyAgKiAtIEFSQyBzdGFydHMgaW5jcmVhc2luZyBpdHMgYWxsb2Nh dGlvbiBhZ2FpbiwgYW5kIHdpcmVkIG1lbW9yeSBncm93cy4KKyAgKiAtIEEgbmV3IGltYWdlIGlz IGFjdGl2YXRlZCwgYW5kIHRoZSBzeXN0ZW0gb25jZSBhZ2FpbiBhdHRlbXB0cyB0byBwYWdlLgor ICAqIC0gQVJDIHN0YXJ0cyB0byBiZSBldmljdGVkIGFnYWluLgorICAqIC0gQmFjayB0byAjMgor ICAqIAorICAqIE5vdGUgdGhhdCBaRlMncyBBUkMgZGVmYXVsdCAodW5sZXNzIHlvdSBvdmVycmlk ZSBpdCBpbiAvYm9vdC9sb2FkZXIuY29uZikKKyAgKiBpcyB0byBhbGxvdyB0aGUgQVJDIGNhY2hl IHRvIGdyYWIgbmVhcmx5IGFsbCBvZiBmcmVlIFJBTSwgcHJvdmlkZWQgbm9ib2R5CisgICogZWxz ZSBuZWVkcyBpdC4gIFRoYXQgd291bGQgYmUgb2sgaWYgd2UgZXZpY3RlZCBjYWNoZSB3aGVuIHJl cXVpcmVkLgorICAqIAorICAqIFVuZm9ydHVuYXRlbHkgdGhlIHN5c3RlbSBjYW4gZ2V0IGludG8g YSBzdGF0ZSB3aGVyZSBpdCBuZXZlcgorICAqIG1hbmFnZXMgdG8gcGFnZSBhbnl0aGluZyBvZiBt YXRlcmlhbGl0eSBiYWNrIGluLCBhcyBpZiB0aGVyZSBpcyBhY3RpdmUKKyAgKiBJL08gdGhlIEFS QyB3aWxsIHN0YXJ0IGdyYWJiaW5nIHNwYWNlIG9uY2UgYWdhaW4gYXMgc29vbiBhcyB0aGUgbWVt b3J5IAorICAqIGNvbnRlbnRpb24gc3RhdGUgZHJvcHMuICBGb3IgdGhpcyByZWFzb24gdGhlICJw YWdpbmcgaXMgb2NjdXJyaW5nIiBmbGFnIAorICAqIHNob3VsZCBiZSB0aGUgKipsYXN0IHJlc29y dCoqIGNvbmRpdGlvbiBmb3IgQVJDIGV2aWN0aW9uOyB5b3Ugd2FudCB0byAKKyAgKiAoYXMgU29s YXJpcyBkb2VzKSBzdGFydCB3aGVuIHRoZXJlIGlzIG1hdGVyaWFsIGZyZWUgUkFNIGxlZnQgQlVU IHRoZQorICAqIHZtIHN5c3RlbSB0aGlua3MgaXQgbmVlZHMgdG8gYmUgYWN0aXZlIHRvIHN0ZWFs IHBhZ2VzIGJhY2sgaW4gdGhlIGF0dGVtcHQKKyAgKiB0byBuZXZlciBnZXQgaW50byB0aGUgY29u ZGl0aW9uIHdoZXJlIHlvdSdyZSBwb3RlbnRpYWxseSBwYWdpbmcgb2ZmIAorICAqIGV4ZWN1dGFi bGVzIGluIGZhdm9yIG9mIGxlYXZpbmcgZGlzayBjYWNoZSBhbGxvY2F0ZWQuCisgICoKKyAgKiBU byBmaXggdGhpcyB3ZSBjaGFuZ2UgaG93IHdlIGxvb2sgYXQgbG93IG1lbW9yeSwgZGVjbGFyaW5n IHR3byBuZXcKKyAgKiBydW50aW1lIHR1bmFibGVzIGFuZCBvbmUgc3RhdHVzLgorICAqIAorICAq IFRoZSBuZXcgc3lzY3RscyBhcmU6CisgICogdmZzLnpmcy5hcmNfZnJlZXBhZ2VzIChmcmVlIHBh Z2VzIHJlcXVpcmVkIHRvIGNhbGwgUkFNICJzdWZmaWNpZW50IikKKyAgKiB2ZnMuemZzLmFyY19z aHJpbmtfbmVlZGVkIChzaG93cyAiMSIgaWYgd2UncmUgYXNraW5nIGZvciBzaHJpbmtpbmcgdGhl IEFSQykKKyAgKiAKKyAgKiB2ZnMuemZzLmFyY19mcmVlcGFnZXMgaXMgaW5pdGlhbGl6ZWQgZnJv bSB2bS52X2ZyZWVfdGFyZ2V0LgorICAqIFRoaXMgc2hvdWxkIGluc3VyZSB0aGF0IHdlIGFsbG93 IHRoZSBWTSBzeXN0ZW0gdG8gc3RlYWwgcGFnZXMsCisgICogYnV0IHBhcmUgdGhlIGNhY2hlIGJl Zm9yZSB3ZSBzdXNwZW5kIHByb2Nlc3NlcyBhdHRlbXB0aW5nIHRvIGdldCBtb3JlCisgICogbWVt b3J5LCB0aGVyZWJ5IGF2b2lkaW5nICJzdGFsbHMuIiAgWW91IGNhbiBzZXQgdGhpcyBoaWdoZXIg aWYgeW91IHdpc2gsCisgICogYnV0IGRvaW5nIHNvIG1heSBjYXVzZSB0aGUgY2FjaGUgdG8gcGFy ZSBiYWNrIHdoaWxlIHRoZSBWTSBzeXN0ZW0gCisgICogcmVtYWlucyB3aWxsaW5nIHRvIGFsbG93 ICJpbmFjdGl2ZSIgcGFnZXMgdG8gYWNjdW11bGF0ZS4gIFRoZSBjaGFsbGVuZ2UgCisgICogaXMg dGhhdCBpbWFnZSBhY3RpdmF0aW9uIGNhbiBmb3JjZSB0aGluZ3MgaW50byB0aGUgcGFnZSBzcGFj ZSBvbiBhIAorICAqIHJlcGVhdGVkIGJhc2lzIGlmIHlvdSBhbGxvdyB0aGlzIGxldmVsIHRvIGJl IHRvbyBzbWFsbCAodGhlIGFib3ZlIAorICAqIHBhdGhvbG9naWNhbCBiZWhhdmlvcik7IHRoZSBk ZWZhdWx0cyBzaG91bGQgYXZvaWQgdGhhdCBiZWhhdmlvciBidXQgdGhlIAorICAqIHN5c2N0bCBp cyBleHBvc2VkIHNob3VsZCB5b3VyIHdvcmtsb2FkIHJlcXVpcmUgYWRqdXN0bWVudC4KKyAgKgor ICAqIElmIHdlJ3JlIHVzaW5nIHRoaXMgY2hlY2sgZm9yIGxvdyBtZW1vcnkgd2UgYXJlIHJlcGxh Y2luZyB0aGUgcHJldmlvdXMKKyAgKiBvbmVzLCBpbmNsdWRpbmcgdGhlIG9kZGJhbGwgInJhbmRv bSIgcmVjbGFpbSB0aGF0IGFwcGVhcnMgdG8gZmlyZSBmYXIKKyAgKiBtb3JlIG9mdGVuIHRoYW4g aXQgc2hvdWxkLiAgV2Ugc3RpbGwgdHJpZ2dlciBpZiB0aGUgc3lzdGVtIHBhZ2VzLgorICAqCisg ICogSWYgeW91IHR1cm4gb24gTkVXUkVDTEFJTV9ERUJVRyB0aGVuIHRoZSBrZXJuZWwgd2lsbCBw cmludCBvbiB0aGUgY29uc29sZQorICAqIHN0YXR1cyBtZXNzYWdlcyB3aGVuIHRoZSByZWNsYWlt IHN0YXR1cyB0cmlwcyBvbiBhbmQgb2ZmLCBhbG9uZyB3aXRoIHRoZQorICAqIHBhZ2UgY291bnQg YWdncmVnYXRlIHRoYXQgdHJpZ2dlcmVkIGl0IChhbmQgdGhlIGZyZWUgc3BhY2UpIGZvciBlYWNo CisgICogZXZlbnQuIAorICAqLworIAorICNkZWZpbmUJTkVXUkVDTEFJTQorICN1bmRlZglORVdS RUNMQUlNX0RFQlVHCisgCisgCiAgLyoKICAgKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMTAsIE9y YWNsZSBhbmQvb3IgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgICogQ29w eXJpZ2h0IChjKSAyMDEzIGJ5IERlbHBoaXguIEFsbCByaWdodHMgcmVzZXJ2ZWQuCioqKioqKioq KioqKioqKgoqKiogMTM5LDE0NCAqKioqCi0tLSAyMDksMjI4IC0tLS0KICAKICAjaW5jbHVkZSA8 dm0vdm1fcGFnZW91dC5oPgogIAorICNpZmRlZglORVdSRUNMQUlNCisgI2lmZGVmCV9fRnJlZUJT RF9fCisgI2luY2x1ZGUgPHN5cy9zeXNjdGwuaD4KKyAjaW5jbHVkZSA8c3lzL3ZtbWV0ZXIuaD4K KyAvKgorICAqIFN0cnVjdCBjbnQuIHdhcyByZW5hbWVkIGluIC1oZWFkICgxMS1jdXJyZW50KSBh dCByZXYgMTEwMDE2OyBjaGVjayBmb3IgaXQKKyAgKi8KKyAjaWYgX19GcmVlQlNEX3ZlcnNpb24g PCAxMTAwMDE2CisgI2RlZmluZQl2bV9jbnQJY250CisgI2VuZGlmCS8qIF9fRnJlZUJTRF92ZXJz aW9uICovCisgCisgI2VuZGlmCS8qIF9fRnJlZUJTRF9fICovCisgI2VuZGlmCS8qIE5FV1JFQ0xB SU0gKi8KKyAKICAjaWZkZWYgaWxsdW1vcwogICNpZm5kZWYgX0tFUk5FTAogIC8qIHNldCB3aXRo IFpGU19ERUJVRz13YXRjaCwgdG8gZW5hYmxlIHdhdGNocG9pbnRzIG9uIGZyb3plbiBidWZmZXJz ICovCioqKioqKioqKioqKioqKgoqKiogMjAzLDIyMyAqKioqCi0tLSAyODcsMzI3IC0tLS0KICBp bnQgemZzX2FyY19zaHJpbmtfc2hpZnQgPSAwOwogIGludCB6ZnNfYXJjX3BfbWluX3NoaWZ0ID0g MDsKICBpbnQgemZzX2Rpc2FibGVfZHVwX2V2aWN0aW9uID0gMDsKICB1aW50NjRfdCB6ZnNfYXJj X2F2ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEwMjQ7IC8qIDhLQiAqLworICNpZmRlZglORVdSRUNM QUlNCisgI2lmZGVmICBfX0ZyZWVCU0RfXworIHN0YXRpYwlpbnQgZnJlZXBhZ2VzID0gMDsJLyog VGhpcyBtdWNoIG1lbW9yeSBpcyBjb25zaWRlcmVkIGNyaXRpY2FsICovCisgc3RhdGljCWludCBz aHJpbmtfbmVlZGVkID0gMDsJLyogU2hyaW5rYWdlIG9mIEFSQyBjYWNoZSBuZWVkZWQ/CSovCisg I2VuZGlmCS8qIF9fRnJlZUJTRF9fICovCisgI2VuZGlmCS8qIE5FV1JFQ0xBSU0gKi8KICAKICBU VU5BQkxFX1FVQUQoInZmcy56ZnMuYXJjX21heCIsICZ6ZnNfYXJjX21heCk7CiAgVFVOQUJMRV9R VUFEKCJ2ZnMuemZzLmFyY19taW4iLCAmemZzX2FyY19taW4pOwogIFRVTkFCTEVfUVVBRCgidmZz Lnpmcy5hcmNfbWV0YV9saW1pdCIsICZ6ZnNfYXJjX21ldGFfbGltaXQpOwogIFRVTkFCTEVfUVVB RCgidmZzLnpmcy5hcmNfYXZlcmFnZV9ibG9ja3NpemUiLCAmemZzX2FyY19hdmVyYWdlX2Jsb2Nr c2l6ZSk7CisgI2lmZGVmCU5FV1JFQ0xBSU0KKyAjaWZkZWYgIF9fRnJlZUJTRF9fCisgVFVOQUJM RV9JTlQoInZmcy56ZnMuYXJjX2ZyZWVwYWdlcyIsICZmcmVlcGFnZXMpOworIFRVTkFCTEVfSU5U KCJ2ZnMuemZzLmFyY19zaHJpbmtfbmVlZGVkIiwgJnNocmlua19uZWVkZWQpOworICNlbmRpZgkv KiBfX0ZyZWVCU0RfXyAqLworICNlbmRpZgkvKiBORVdSRUNMQUlNICovCisgCiAgU1lTQ1RMX0RF Q0woX3Zmc196ZnMpOwogIFNZU0NUTF9VUVVBRChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19tYXgs IENUTEZMQUdfUkRUVU4sICZ6ZnNfYXJjX21heCwgMCwKICAgICAgIk1heGltdW0gQVJDIHNpemUi KTsKICBTWVNDVExfVVFVQUQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfbWluLCBDVExGTEFHX1JE VFVOLCAmemZzX2FyY19taW4sIDAsCiAgICAgICJNaW5pbXVtIEFSQyBzaXplIik7CiAgU1lTQ1RM X1VRVUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCBDVExGTEFH X1JEVFVOLAogICAgICAmemZzX2FyY19hdmVyYWdlX2Jsb2Nrc2l6ZSwgMCwKICAgICAgIkFSQyBh dmVyYWdlIGJsb2Nrc2l6ZSIpOwogIAorICNpZmRlZglORVdSRUNMQUlNCisgI2lmZGVmICBfX0Zy ZWVCU0RfXworIFNZU0NUTF9JTlQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfZnJlZXBhZ2VzLCBD VExGTEFHX1JXVFVOLCAmZnJlZXBhZ2VzLCAwLCAiQVJDIEZyZWUgUkFNIFBhZ2VzIFJlcXVpcmVk Iik7CisgU1lTQ1RMX0lOVChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19zaHJpbmtfbmVlZGVkLCBD VExGTEFHX1JELCAmc2hyaW5rX25lZWRlZCwgMCwgIkFSQyBNZW1vcnkgQ29uc3RyYWluZWQgKDAg PSBubywgMSA9IHllcykiKTsKKyAjZW5kaWYJLyogX19GcmVlQlNEX18gKi8KKyAjZW5kaWYJLyog TkVXUkVDTEFJTSAqLworIAogIC8qCiAgICogTm90ZSB0aGF0IGJ1ZmZlcnMgY2FuIGJlIGluIG9u ZSBvZiA2IHN0YXRlczoKICAgKglBUkNfYW5vbgktIGFub255bW91cyAoZGlzY3Vzc2VkIGJlbG93 KQoqKioqKioqKioqKioqKioKKioqIDI0NTQsMjQ1OSAqKioqCi0tLSAyNTU4LDI1NjcgLS0tLQog IHsKICAKICAjaWZkZWYgX0tFUk5FTAorICNpZmRlZglORVdSRUNMQUlNX0RFQlVHCisgCXN0YXRp YwlpbnQJeHZhbCA9IC0xOworIAlzdGF0aWMJaW50CW9sZGZyZWVwYWdlcyA9IDA7CisgI2VuZGlm CS8qIE5FV1JFQ0xBSU1fREVCVUcgKi8KICAKICAJaWYgKG5lZWRmcmVlKQogIAkJcmV0dXJuICgx KTsKKioqKioqKioqKioqKioqCioqKiAyNDkyLDI0OTcgKioqKgotLS0gMjYwMCwyNjA2IC0tLS0K ICAJCXJldHVybiAoMSk7CiAgCiAgI2lmIGRlZmluZWQoX19pMzg2KQorIAogIAkvKgogIAkgKiBJ ZiB3ZSdyZSBvbiBhbiBpMzg2IHBsYXRmb3JtLCBpdCdzIHBvc3NpYmxlIHRoYXQgd2UnbGwgZXho YXVzdCB0aGUKICAJICoga2VybmVsIGhlYXAgc3BhY2UgYmVmb3JlIHdlIGV2ZXIgcnVuIG91dCBv ZiBhdmFpbGFibGUgcGh5c2ljYWwKKioqKioqKioqKioqKioqCioqKiAyNTA4LDI1MTggKioqKgog IAkJcmV0dXJuICgxKTsKICAjZW5kaWYKICAjZWxzZQkvKiAhc3VuICovCiAgCWlmIChrbWVtX3Vz ZWQoKSA+IChrbWVtX3NpemUoKSAqIDMpIC8gNCkKICAJCXJldHVybiAoMSk7CiAgI2VuZGlmCS8q IHN1biAqLwogIAotICNlbHNlCiAgCWlmIChzcGFfZ2V0X3JhbmRvbSgxMDApID09IDApCiAgCQly ZXR1cm4gKDEpOwogICNlbmRpZgotLS0gMjYxNywyNjc3IC0tLS0KICAJCXJldHVybiAoMSk7CiAg I2VuZGlmCiAgI2Vsc2UJLyogIXN1biAqLworIAorICNpZmRlZglORVdSRUNMQUlNCisgI2lmZGVm ICBfX0ZyZWVCU0RfXworIC8qCisgICogSW1wbGVtZW50IHRoZSBuZXcgdHVuYWJsZSBmcmVlIFJB TSBhbGdvcml0aG0uICBXZSBjaGVjayB0aGUgZnJlZSBwYWdlcworICAqIGFnYWluc3QgdGhlIG1p bmltdW0gc3BlY2lmaWVkIHRhcmdldCBhbmQgdGhlIHBlcmNlbnRhZ2UgdGhhdCBzaG91bGQgYmUK KyAgKiBmcmVlLiAgSWYgd2UncmUgbG93IHdlIGFzayBmb3IgQVJDIGNhY2hlIHNocmlua2FnZS4g IElmIHRoaXMgaXMgZGVmaW5lZCAKKyAgKiBvbiBhIEZyZWVCU0Qgc3lzdGVtIHRoZSBvbGRlciBj aGVja3MgYXJlIG5vdCBwZXJmb3JtZWQuCisgICoKKyAgKiBDaGVjayBmaXJzdCB0byBzZWUgaWYg d2UgbmVlZCB0byBpbml0IGZyZWVwYWdlcywgdGhlbiB0ZXN0LgorICAqLworIAlpZiAoIWZyZWVw YWdlcykgewkJLyogSWYgemVybyB0aGVuIChyZSlpbml0ICovCisgCQlmcmVlcGFnZXMgPSB2bV9j bnQudl9mcmVlX3RhcmdldDsKKyAjaWZkZWYJTkVXUkVDTEFJTV9ERUJVRworIAkJcHJpbnRmKCJa RlMgQVJDOiBEZWZhdWx0IHZmcy56ZnMuYXJjX2ZyZWVwYWdlcyB0byBbJXVdXG4iLCBmcmVlcGFn ZXMpOworICNlbmRpZgkvKiBORVdSRUNMQUlNX0RFQlVHICovCisgCX0KKyAjaWZkZWYJTkVXUkVD TEFJTV9ERUJVRworIAlpZiAoZnJlZXBhZ2VzICE9IG9sZGZyZWVwYWdlcykgeworIAkJcHJpbnRm KCJaRlMgQVJDOiBMb3cgUkFNIHBhZ2UgY2hhbmdlIHRvIFslZF0sIFslZF0gcGFnZXMsIFslZF0g ZnJlZVxuIiwgZnJlZXBhZ2VzLCB2bV9jbnQudl9wYWdlX2NvdW50LCB2bV9jbnQudl9mcmVlX2Nv dW50KTsKKyAJCW9sZGZyZWVwYWdlcyA9IGZyZWVwYWdlczsKKyAJfQorICNlbmRpZgkvKiBORVdS RUNMQUlNX0RFQlVHICovCisgLyoKKyAgKiBOb3cgZmlndXJlIG91dCBob3cgbXVjaCBmcmVlIFJB TSB3ZSByZXF1aXJlIHRvIGNhbGwgdGhlIEFSQyBjYWNoZSBzdGF0dXMKKyAgKiAib2siLiAgQWRk IHRoZSBwZXJjZW50YWdlIHNwZWNpZmllZCBvZiB0aGUgdG90YWwgdG8gdGhlIGJhc2UgcmVxdWly ZW1lbnQuCisgICovCisgCisgCWlmICh2bV9jbnQudl9mcmVlX2NvdW50IDwgZnJlZXBhZ2VzKSB7 CisgI2lmZGVmCU5FV1JFQ0xBSU1fREVCVUcKKyAJCWlmICh4dmFsICE9IDEpIHsKKyAJCQlwcmlu dGYoIlpGUyBBUkM6IFJFQ0xBSU0gdG90YWwgJXUsIGZyZWUgJXUsIGZyZWUgcGN0ICgldSksIHJl c2VydmVkICgldSlcbiIsIHZtX2NudC52X3BhZ2VfY291bnQsIHZtX2NudC52X2ZyZWVfY291bnQs ICgodm1fY250LnZfZnJlZV9jb3VudCAqIDEwMCkgLyB2bV9jbnQudl9wYWdlX2NvdW50KSwgZnJl ZXBhZ2VzKTsKKyAJCQl4dmFsID0gMTsKKyAJCX0KKyAjZW5kaWYJLyogTkVXUkVDTEFJTV9ERUJV RyAqLworIAkJc2hyaW5rX25lZWRlZCA9IDE7CisgCQlyZXR1cm4oMSk7CisgCX0gZWxzZSB7Cisg I2lmZGVmCU5FV1JFQ0xBSU1fREVCVUcKKyAJCWlmICh4dmFsICE9IDApIHsKKyAJCQlwcmludGYo IlpGUyBBUkM6IE5PUk1BTCB0b3RhbCAldSwgZnJlZSAldSwgZnJlZSBwY3QgKCV1KSwgcmVzZXJ2 ZWQgKCV1KVxuIiwgdm1fY250LnZfcGFnZV9jb3VudCwgdm1fY250LnZfZnJlZV9jb3VudCwgKCh2 bV9jbnQudl9mcmVlX2NvdW50ICogMTAwKSAvIHZtX2NudC52X3BhZ2VfY291bnQpLCBmcmVlcGFn ZXMpOworIAkJCXh2YWwgPSAwOworIAkJfQorICNlbmRpZgkvKiBORVdSRUNMQUlNX0RFQlVHICov CisgCQlzaHJpbmtfbmVlZGVkID0gMDsKKyAJCXJldHVybigwKTsKKyAJfQorIAorICNlbmRpZgkv KiBfX0ZyZWVCU0RfXyAqLworICNlbmRpZgkvKiBORVdSRUNMQUlNICovCisgCiAgCWlmIChrbWVt X3VzZWQoKSA+IChrbWVtX3NpemUoKSAqIDMpIC8gNCkKICAJCXJldHVybiAoMSk7CiAgI2VuZGlm CS8qIHN1biAqLwogIAogIAlpZiAoc3BhX2dldF9yYW5kb20oMTAwKSA9PSAwKQogIAkJcmV0dXJu ICgxKTsKICAjZW5kaWYK 146373 2014-08-27 12:20:46 +0000 2014-08-27 23:18:01 +0000 arc reclaim refactor (against head) arc-reclaim-head.patch text/plain 7082 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MDQyMikKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTI2LDIwICsx MjYsNDIgQEAKIH0KIFNZU0lOSVQoa21lbV9zaXplX2luaXQsIFNJX1NVQl9LTUVNLCBTSV9PUkRF Ul9BTlksIGttZW1fc2l6ZV9pbml0LCBOVUxMKTsKIAorLyoKKyAqIFRoZSByZXR1cm5zIGZyb20g a21lbV9mcmVlXypzaXplIGFyZSBvbmx5IHZhbGlkIG9uY2UgdGhlIHBhZ2VkYWVtb24KKyAqIGhh cyBiZWVuIGluaXRpYWxpc2VkLCBiZWZvcmUgdGhlbiB0aGV5IHJldHVybiAwLgorICogCisgKiBU byBlbnN1cmUgdGhlIHJldHVybnMgYXJlIHZhbGlkIHRoZSBjYWxsZXIgY2FuIHVzZSBhIFNZU0lO SVQgd2l0aAorICogc3Vic3lzdGVtIHNldCB0byBTSV9TVUJfS1RIUkVBRF9QQUdFIGFuZCBvcmRl ciBvZiBhdCBsZWFzdAorICogU0lfT1JERVJfU0VDT05ELgorICovCiB1aW50NjRfdAota21lbV9z aXplKHZvaWQpCitrbWVtX2ZyZWVfdGFyZ2V0X3NpemUodm9pZCkKIHsKIAotCXJldHVybiAoa21l bV9zaXplX3ZhbCk7CisJcmV0dXJuICgodWludDY0X3Qpdm1fY250LnZfZnJlZV90YXJnZXQgKiBQ QUdFX1NJWkUpOwogfQogCiB1aW50NjRfdAota21lbV91c2VkKHZvaWQpCitrbWVtX2ZyZWVfbWlu X3NpemUodm9pZCkKIHsKIAotCXJldHVybiAodm1lbV9zaXplKGttZW1fYXJlbmEsIFZNRU1fQUxM T0MpKTsKKwlyZXR1cm4gKCh1aW50NjRfdCl2bV9jbnQudl9mcmVlX21pbiAqIFBBR0VfU0laRSk7 CiB9CiAKK3VpbnQ2NF90CitrbWVtX2ZyZWVfc2l6ZSh2b2lkKQoreworCisJcmV0dXJuICgodWlu dDY0X3Qpdm1fY250LnZfZnJlZV9jb3VudCAqIFBBR0VfU0laRSk7Cit9CisKK3VpbnQ2NF90Citr bWVtX3NpemUodm9pZCkKK3sKKworCXJldHVybiAoa21lbV9zaXplX3ZhbCk7Cit9CisKIHN0YXRp YyBpbnQKIGttZW1fc3RkX2NvbnN0cnVjdG9yKHZvaWQgKm1lbSwgaW50IHNpemUgX191bnVzZWQs IHZvaWQgKnByaXZhdGUsIGludCBmbGFncykKIHsKSW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVu c29sYXJpcy9zeXMva21lbS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9zeXMva21lbS5oCShyZXZpc2lvbiAyNzA0MjIpCisrKyBzeXMvY2RkbC9jb21wYXQvb3Bl bnNvbGFyaXMvc3lzL2ttZW0uaAkod29ya2luZyBjb3B5KQpAQCAtNjYsNyArNjYsMTIgQEAKIHZv aWQgKnpmc19rbWVtX2FsbG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19r bWVtX2ZyZWUodm9pZCAqYnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9p ZCk7Ci11aW50NjRfdCBrbWVtX3VzZWQodm9pZCk7CisKKy8qIFJldHVybiB2YWxzIGZyb20ga21l bV9mcmVlXypzaXplIGFyZSBvbmx5IHZhbGlkIGFmdGVyIHRoZSBwYWdlZGFlbW9uIGluaXQuICov Cit1aW50NjRfdCBrbWVtX2ZyZWVfc2l6ZSh2b2lkKTsKK3VpbnQ2NF90IGttZW1fZnJlZV90YXJn ZXRfc2l6ZSh2b2lkKTsKK3VpbnQ2NF90IGttZW1fZnJlZV9taW5fc2l6ZSh2b2lkKTsKKwoga21l bV9jYWNoZV90ICprbWVtX2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3QgYnVmc2l6ZSwg c2l6ZV90IGFsaWduLAogICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZvaWQgKiwgaW50 KSwgdm9pZCAoKmRlc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lkICgqcmVjbGFp bSkodm9pZCAqKSBfX3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAsIGludCBjZmxh Z3MpOwpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pm cy9hcmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9j b21tb24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzA0MjIpCisrKyBzeXMvY2RkbC9jb250cmli L29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3b3JraW5nIGNvcHkpCkBAIC0x OTMsOSArMTkzLDYgQEAKICAqLwogc3RhdGljIGJvb2xlYW5fdCBhcmNfd2FybTsKIAotLyoKLSAq IFRoZXNlIHR1bmFibGVzIGFyZSBmb3IgcGVyZm9ybWFuY2UgYW5hbHlzaXMuCi0gKi8KIHVpbnQ2 NF90IHpmc19hcmNfbWF4OwogdWludDY0X3QgemZzX2FyY19taW47CiB1aW50NjRfdCB6ZnNfYXJj X21ldGFfbGltaXQgPSAwOwpAQCAtMjA0LDcgKzIwMSwyMSBAQAogaW50IHpmc19hcmNfcF9taW5f c2hpZnQgPSAwOwogaW50IHpmc19kaXNhYmxlX2R1cF9ldmljdGlvbiA9IDA7CiB1aW50NjRfdCB6 ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEwMjQ7IC8qIDhLQiAqLwordWludDY0X3Qg emZzX2FyY19mcmVlX3RhcmdldCA9ICgxIDw8IDMwKTsgLyogMUdCIHByZSBwYWdlZGFlbW9uIGlu aXQgb25seSAqLwogCitzdGF0aWMgaW50IHN5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldChT WVNDVExfSEFORExFUl9BUkdTKTsKKworI2lmZGVmIF9LRVJORUwKK3N0YXRpYyB2b2lkCithcmNf ZnJlZV90YXJnZXRfaW5pdCh2b2lkICp1bnVzZWQgX191bnVzZWQpCit7CisKKwl6ZnNfYXJjX2Zy ZWVfdGFyZ2V0ID0ga21lbV9mcmVlX3RhcmdldF9zaXplKCk7Cit9CitTWVNJTklUKGFyY19mcmVl X3RhcmdldF9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9BTlksCisgICAgYXJj X2ZyZWVfdGFyZ2V0X2luaXQsIE5VTEwpOworI2VuZGlmCisKIFRVTkFCTEVfUVVBRCgidmZzLnpm cy5hcmNfbWV0YV9saW1pdCIsICZ6ZnNfYXJjX21ldGFfbGltaXQpOwogU1lTQ1RMX0RFQ0woX3Zm c196ZnMpOwogU1lTQ1RMX1VRVUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX21heCwgQ1RMRkxB R19SRFRVTiwgJnpmc19hcmNfbWF4LCAwLApAQCAtMjE0LDcgKzIyNSwzNCBAQAogU1lTQ1RMX1VR VUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCBDVExGTEFHX1JE VFVOLAogICAgICZ6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCAwLAogICAgICJBUkMgYXZlcmFn ZSBibG9ja3NpemUiKTsKKy8qCisgKiBXZSBkb24ndCBoYXZlIGEgdHVuYWJsZSBmb3IgYXJjX2Zy ZWVfdGFyZ2V0IGR1ZSB0byB0aGUgZGVwZW5kZW5jeSBvbgorICogcGFnZWRhZW1vbiBpbml0aWFs aXNhdGlvbi4KKyAqLworU1lTQ1RMX1BST0MoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfZnJlZV90 YXJnZXQsCisgICAgQ1RMVFlQRV9VNjQgfCBDVExGTEFHX01QU0FGRSB8IENUTEZMQUdfUlcsIDAs IHNpemVvZih1aW50NjRfdCksCisgICAgc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0LCAi UVUiLAorICAgICJEZXNpcmVkIGFtb3VudCBvZiBmcmVlIG1lbW9yeSBiZWxvdyB3aGljaCBBUkMg dHJpZ2dlcnMgcmVjbGFpbSIpOwogCitzdGF0aWMgaW50CitzeXNjdGxfdmZzX3pmc19hcmNfZnJl ZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUykKK3sKKwl1aW50NjRfdCB2YWw7CisJaW50IGVy cjsKKworCXZhbCA9IHpmc19hcmNfZnJlZV90YXJnZXQ7CisJZXJyID0gc3lzY3RsX2hhbmRsZV82 NChvaWRwLCAmdmFsLCAwLCByZXEpOworCWlmIChlcnIgIT0gMCB8fCByZXEtPm5ld3B0ciA9PSBO VUxMKQorCQlyZXR1cm4gKGVycik7CisKKwlpZiAodmFsIDwga21lbV9mcmVlX21pbl9zaXplKCkp CisJCXJldHVybiAoRUlOVkFMKTsKKworCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2YWw7CisKKwly ZXR1cm4gKDApOworfQorCiAvKgogICogTm90ZSB0aGF0IGJ1ZmZlcnMgY2FuIGJlIGluIG9uZSBv ZiA2IHN0YXRlczoKICAqCUFSQ19hbm9uCS0gYW5vbnltb3VzIChkaXNjdXNzZWQgYmVsb3cpCkBA IC0yNDE4LDkgKzI0NTYsMTIgQEAKIHZvaWQKIGFyY19zaHJpbmsodm9pZCkKIHsKKwogCWlmIChh cmNfYyA+IGFyY19jX21pbikgewogCQl1aW50NjRfdCB0b19mcmVlOwogCisJCURUUkFDRV9QUk9C RTIoYXJjX19zaHJpbmssIHVpbnQ2NF90LCBhcmNfYywgdWludDY0X3QsCisJCQlhcmNfY19taW4p OwogI2lmZGVmIF9LRVJORUwKIAkJdG9fZnJlZSA9IGFyY19jID4+IGFyY19zaHJpbmtfc2hpZnQ7 CiAjZWxzZQpAQCAtMjQ0MCw4ICsyNDgxLDExIEBACiAJCUFTU0VSVCgoaW50NjRfdClhcmNfcCA+ PSAwKTsKIAl9CiAKLQlpZiAoYXJjX3NpemUgPiBhcmNfYykKKwlpZiAoYXJjX3NpemUgPiBhcmNf YykgeworCQlEVFJBQ0VfUFJPQkUyKGFyY19fc2hyaW5rX2FkanVzdCwgdWludDY0X3QsIGFyY19z aXplLAorCQkJdWludDY0X3QsIGFyY19jKTsKIAkJYXJjX2FkanVzdCgpOworCX0KIH0KIAogc3Rh dGljIGludCBuZWVkZnJlZSA9IDA7CkBAIC0yNDUyLDE1ICsyNDk2LDI1IEBACiAKICNpZmRlZiBf S0VSTkVMCiAKLQlpZiAobmVlZGZyZWUpCisJaWYgKG5lZWRmcmVlKSB7CisJCURUUkFDRV9QUk9C RShhcmNfX3JlY2xhaW1fbmVlZGZyZWUpOwogCQlyZXR1cm4gKDEpOworCX0KIAorCWlmIChrbWVt X2ZyZWVfc2l6ZSgpIDwgemZzX2FyY19mcmVlX3RhcmdldCkgeworCQlEVFJBQ0VfUFJPQkUyKGFy Y19fcmVjbGFpbV9mcmVldGFyZ2V0LCB1aW50NjRfdCwKKwkJICAgIGttZW1fZnJlZV9zaXplKCks IHVpbnQ2NF90LCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KTsKKwkJcmV0dXJuICgxKTsKKwl9CisKIAkv KgogCSAqIENvb3BlcmF0ZSB3aXRoIHBhZ2VkYWVtb24gd2hlbiBpdCdzIHRpbWUgZm9yIGl0IHRv IHNjYW4KIAkgKiBhbmQgcmVjbGFpbSBzb21lIHBhZ2VzLgogCSAqLwotCWlmICh2bV9wYWdpbmdf bmVlZGVkKCkpCisJaWYgKHZtX3BhZ2luZ19uZWVkZWQoKSkgeworCQlEVFJBQ0VfUFJPQkUoYXJj X19yZWNsYWltX3BhZ2luZyk7CiAJCXJldHVybiAoMSk7CisJfQogCiAjaWZkZWYgc3VuCiAJLyoK QEAgLTI1MDQsOSArMjU1OCw2IEBACiAJICAgIChidG9wKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBW TUVNX0ZSRUUgfCBWTUVNX0FMTE9DKSkgPj4gMikpCiAJCXJldHVybiAoMSk7CiAjZW5kaWYKLSNl bHNlCS8qICFzdW4gKi8KLQlpZiAoa21lbV91c2VkKCkgPiAoa21lbV9zaXplKCkgKiAzKSAvIDQp Ci0JCXJldHVybiAoMSk7CiAjZW5kaWYJLyogc3VuICovCiAKICNlbHNlCkBAIC0yNTEzLDYgKzI1 NjQsOCBAQAogCWlmIChzcGFfZ2V0X3JhbmRvbSgxMDApID09IDApCiAJCXJldHVybiAoMSk7CiAj ZW5kaWYKKwlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX25vKTsKKwogCXJldHVybiAoMCk7CiB9 CiAKSW5kZXg6IHN5cy92bS92bV9wYWdlb3V0LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL3ZtL3ZtX3Bh Z2VvdXQuYwkocmV2aXNpb24gMjcwNDIyKQorKysgc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkod29ya2lu ZyBjb3B5KQpAQCAtMTE1LDEwICsxMTUsMTQgQEAKIAogLyogdGhlIGtlcm5lbCBwcm9jZXNzICJ2 bV9wYWdlb3V0IiovCiBzdGF0aWMgdm9pZCB2bV9wYWdlb3V0KHZvaWQpOworc3RhdGljIHZvaWQg dm1fcGFnZW91dF9pbml0KHZvaWQpOwogc3RhdGljIGludCB2bV9wYWdlb3V0X2NsZWFuKHZtX3Bh Z2VfdCk7CiBzdGF0aWMgdm9pZCB2bV9wYWdlb3V0X3NjYW4oc3RydWN0IHZtX2RvbWFpbiAqdm1k LCBpbnQgcGFzcyk7CiBzdGF0aWMgdm9pZCB2bV9wYWdlb3V0X21pZ2h0YmVfb29tKHN0cnVjdCB2 bV9kb21haW4gKnZtZCwgaW50IHBhc3MpOwogCitTWVNJTklUKHBhZ2VkYWVtb25faW5pdCwgU0lf U1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfRklSU1QsIHZtX3BhZ2VvdXRfaW5pdCwKKyAgICBO VUxMKTsKKwogc3RydWN0IHByb2MgKnBhZ2Vwcm9jOwogCiBzdGF0aWMgc3RydWN0IGtwcm9jX2Rl c2MgcGFnZV9rcCA9IHsKQEAgLTEyNiw3ICsxMzAsNyBAQAogCXZtX3BhZ2VvdXQsCiAJJnBhZ2Vw cm9jCiB9OwotU1lTSU5JVChwYWdlZGFlbW9uLCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRF Ul9GSVJTVCwga3Byb2Nfc3RhcnQsCitTWVNJTklUKHBhZ2VkYWVtb24sIFNJX1NVQl9LVEhSRUFE X1BBR0UsIFNJX09SREVSX1NFQ09ORCwga3Byb2Nfc3RhcnQsCiAgICAgJnBhZ2Vfa3ApOwogCiAj aWYgIWRlZmluZWQoTk9fU1dBUFBJTkcpCkBAIC0xNjM3LDE1ICsxNjQxLDExIEBACiB9CiAKIC8q Ci0gKgl2bV9wYWdlb3V0IGlzIHRoZSBoaWdoIGxldmVsIHBhZ2VvdXQgZGFlbW9uLgorICoJdm1f cGFnZW91dF9pbml0IGluaXRpYWxpc2VzIGJhc2ljIHBhZ2VvdXQgZGFlbW9uIHNldHRpbmdzLgog ICovCiBzdGF0aWMgdm9pZAotdm1fcGFnZW91dCh2b2lkKQordm1fcGFnZW91dF9pbml0KHZvaWQp CiB7Ci0jaWYgTUFYTUVNRE9NID4gMQotCWludCBlcnJvciwgaTsKLSNlbmRpZgotCiAJLyoKIAkg KiBJbml0aWFsaXplIHNvbWUgcGFnaW5nIHBhcmFtZXRlcnMuCiAJICovCkBAIC0xNjkxLDcgKzE2 OTEsMTggQEAKIAkvKiBYWFggZG9lcyBub3QgcmVhbGx5IGJlbG9uZyBoZXJlICovCiAJaWYgKHZt X3BhZ2VfbWF4X3dpcmVkID09IDApCiAJCXZtX3BhZ2VfbWF4X3dpcmVkID0gdm1fY250LnZfZnJl ZV9jb3VudCAvIDM7Cit9CiAKKy8qCisgKiAgICAgdm1fcGFnZW91dCBpcyB0aGUgaGlnaCBsZXZl bCBwYWdlb3V0IGRhZW1vbi4KKyAqLworc3RhdGljIHZvaWQKK3ZtX3BhZ2VvdXQodm9pZCkKK3sK KyNpZiBNQVhNRU1ET00gPiAxCisJaW50IGVycm9yLCBpOworI2VuZGlmCisKIAlzd2FwX3BhZ2Vy X3N3YXBfaW5pdCgpOwogI2lmIE1BWE1FTURPTSA+IDEKIAlmb3IgKGkgPSAxOyBpIDwgdm1fbmRv bWFpbnM7IGkrKykgewo= 146423 2014-08-27 23:15:07 +0000 2014-08-27 23:18:01 +0000 arc reclaim refactor (against head) arc-reclaim-head.patch text/plain 7507 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MDQyMikKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTI2LDE4ICsx MjYsNDcgQEAga21lbV9zaXplX2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQogfQogU1lTSU5J VChrbWVtX3NpemVfaW5pdCwgU0lfU1VCX0tNRU0sIFNJX09SREVSX0FOWSwga21lbV9zaXplX2lu aXQsIE5VTEwpOwogCi11aW50NjRfdAota21lbV9zaXplKHZvaWQpCisvKgorICogVGhlIHJldHVy biB2YWx1ZXMgZnJvbSBrbWVtX2ZyZWVfKiBhcmUgb25seSB2YWxpZCBvbmNlIHRoZSBwYWdlZGFl bW9uCisgKiBoYXMgYmVlbiBpbml0aWFsaXNlZCwgYmVmb3JlIHRoZW4gdGhleSByZXR1cm4gMC4K KyAqIAorICogVG8gZW5zdXJlIHRoZSByZXR1cm5zIGFyZSB2YWxpZCB0aGUgY2FsbGVyIGNhbiB1 c2UgYSBTWVNJTklUIHdpdGgKKyAqIHN1YnN5c3RlbSBzZXQgdG8gU0lfU1VCX0tUSFJFQURfUEFH RSBhbmQgYW4gb3JkZXIgb2YgYXQgbGVhc3QKKyAqIFNJX09SREVSX1NFQ09ORC4KKyAqLwordV9p bnQKK2ttZW1fZnJlZV90YXJnZXQodm9pZCkKIHsKIAotCXJldHVybiAoa21lbV9zaXplX3ZhbCk7 CisJcmV0dXJuICh2bV9jbnQudl9mcmVlX3RhcmdldCk7CiB9CiAKK3VfaW50CitrbWVtX2ZyZWVf bWluKHZvaWQpCit7CisKKwlyZXR1cm4gKHZtX2NudC52X2ZyZWVfbWluKTsKK30KKwordV9pbnQK K2ttZW1fZnJlZV9jb3VudCh2b2lkKQoreworCisJcmV0dXJuICh2bV9jbnQudl9mcmVlX2NvdW50 KTsKK30KKwordV9pbnQKK2ttZW1fcGFnZV9jb3VudCh2b2lkKQoreworCisJcmV0dXJuICh2bV9j bnQudl9wYWdlX2NvdW50KTsKK30KKwogdWludDY0X3QKLWttZW1fdXNlZCh2b2lkKQora21lbV9z aXplKHZvaWQpCiB7CiAKLQlyZXR1cm4gKHZtZW1fc2l6ZShrbWVtX2FyZW5hLCBWTUVNX0FMTE9D KSk7CisJcmV0dXJuIChrbWVtX3NpemVfdmFsKTsKIH0KIAogc3RhdGljIGludApJbmRleDogc3lz L2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2Nk ZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgJKHJldmlzaW9uIDI3MDQyMikKKysrIHN5 cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCSh3b3JraW5nIGNvcHkpCkBAIC02 Niw3ICs2NiwxNiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZvaWQgKnpmc19rbWVt X2FsbG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19rbWVtX2ZyZWUodm9p ZCAqYnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9pZCk7Ci11aW50NjRf dCBrbWVtX3VzZWQodm9pZCk7Cit1X2ludCBrbWVtX3BhZ2VfY291bnQodm9pZCk7CisKKy8qCisg KiBUaGUgcmV0dXJuIHZhbHVlcyBmcm9tIGttZW1fZnJlZV8qIGFyZSBvbmx5IHZhbGlkIG9uY2Ug dGhlIHBhZ2VkYWVtb24KKyAqIGhhcyBiZWVuIGluaXRpYWxpc2VkLCBiZWZvcmUgdGhlbiB0aGV5 IHJldHVybiAwLgorICovCit1X2ludCBrbWVtX2ZyZWVfY291bnQodm9pZCk7Cit1X2ludCBrbWVt X2ZyZWVfdGFyZ2V0KHZvaWQpOwordV9pbnQga21lbV9mcmVlX21pbih2b2lkKTsKKwoga21lbV9j YWNoZV90ICprbWVtX2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3QgYnVmc2l6ZSwgc2l6 ZV90IGFsaWduLAogICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZvaWQgKiwgaW50KSwg dm9pZCAoKmRlc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lkICgqcmVjbGFpbSko dm9pZCAqKSBfX3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAsIGludCBjZmxhZ3Mp OwpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9h cmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21t b24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzA0MjIpCisrKyBzeXMvY2RkbC9jb250cmliL29w ZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3b3JraW5nIGNvcHkpCkBAIC0xOTMs OSArMTkzLDYgQEAgZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hfZGlzYWJsZTsKICAqLwogc3RhdGlj IGJvb2xlYW5fdCBhcmNfd2FybTsKIAotLyoKLSAqIFRoZXNlIHR1bmFibGVzIGFyZSBmb3IgcGVy Zm9ybWFuY2UgYW5hbHlzaXMuCi0gKi8KIHVpbnQ2NF90IHpmc19hcmNfbWF4OwogdWludDY0X3Qg emZzX2FyY19taW47CiB1aW50NjRfdCB6ZnNfYXJjX21ldGFfbGltaXQgPSAwOwpAQCAtMjA0LDcg KzIwMSwyMSBAQCBpbnQgemZzX2FyY19zaHJpbmtfc2hpZnQgPSAwOwogaW50IHpmc19hcmNfcF9t aW5fc2hpZnQgPSAwOwogaW50IHpmc19kaXNhYmxlX2R1cF9ldmljdGlvbiA9IDA7CiB1aW50NjRf dCB6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEwMjQ7IC8qIDhLQiAqLwordV9pbnQg emZzX2FyY19mcmVlX3RhcmdldCA9ICgxIDw8IDE5KTsgLyogZGVmYXVsdCBiZWZvcmUgcGFnZWRh ZW1vbiBpbml0IG9ubHkgKi8KIAorc3RhdGljIGludCBzeXNjdGxfdmZzX3pmc19hcmNfZnJlZV90 YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CisKKyNpZmRlZiBfS0VSTkVMCitzdGF0aWMgdm9p ZAorYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQoreworCisJemZz X2FyY19mcmVlX3RhcmdldCA9IGttZW1fZnJlZV90YXJnZXQoKTsKK30KK1NZU0lOSVQoYXJjX2Zy ZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX0FOWSwKKyAgICBh cmNfZnJlZV90YXJnZXRfaW5pdCwgTlVMTCk7CisjZW5kaWYKKwogVFVOQUJMRV9RVUFEKCJ2ZnMu emZzLmFyY19tZXRhX2xpbWl0IiwgJnpmc19hcmNfbWV0YV9saW1pdCk7CiBTWVNDVExfREVDTChf dmZzX3pmcyk7CiBTWVNDVExfVVFVQUQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfbWF4LCBDVExG TEFHX1JEVFVOLCAmemZzX2FyY19tYXgsIDAsCkBAIC0yMTQsNyArMjI1LDM2IEBAIFNZU0NUTF9V UVVBRChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19taW4sIENUTEZMQUdfCiBTWVNDVExfVVFVQUQo X3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfYXZlcmFnZV9ibG9ja3NpemUsIENUTEZMQUdfUkRUVU4s CiAgICAgJnpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUsIDAsCiAgICAgIkFSQyBhdmVyYWdlIGJs b2Nrc2l6ZSIpOworLyoKKyAqIFdlIGRvbid0IGhhdmUgYSB0dW5hYmxlIGZvciBhcmNfZnJlZV90 YXJnZXQgZHVlIHRvIHRoZSBkZXBlbmRlbmN5IG9uCisgKiBwYWdlZGFlbW9uIGluaXRpYWxpc2F0 aW9uLgorICovCitTWVNDVExfUFJPQyhfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19mcmVlX3Rhcmdl dCwKKyAgICBDVExUWVBFX1VJTlQgfCBDVExGTEFHX01QU0FGRSB8IENUTEZMQUdfUlcsIDAsIHNp emVvZih1X2ludCksCisgICAgc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0LCAiSVUiLAor ICAgICJEZXNpcmVkIG51bWJlciBvZiBmcmVlIHBhZ2VzIGJlbG93IHdoaWNoIEFSQyB0cmlnZ2Vy cyByZWNsYWltIik7CiAKK3N0YXRpYyBpbnQKK3N5c2N0bF92ZnNfemZzX2FyY19mcmVlX3Rhcmdl dChTWVNDVExfSEFORExFUl9BUkdTKQoreworCXVfaW50IHZhbDsKKwlpbnQgZXJyOworCisJdmFs ID0gemZzX2FyY19mcmVlX3RhcmdldDsKKwllcnIgPSBzeXNjdGxfaGFuZGxlX2ludChvaWRwLCAm dmFsLCAwLCByZXEpOworCWlmIChlcnIgIT0gMCB8fCByZXEtPm5ld3B0ciA9PSBOVUxMKQorCQly ZXR1cm4gKGVycik7CisKKwlpZiAodmFsIDwga21lbV9mcmVlX21pbigpKQorCQlyZXR1cm4gKEVJ TlZBTCk7CisJaWYgKHZhbCA+IGttZW1fcGFnZV9jb3VudCgpKQorCQlyZXR1cm4gKEVJTlZBTCk7 CisKKwl6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gdmFsOworCisJcmV0dXJuICgwKTsKK30KKwogLyoK ICAqIE5vdGUgdGhhdCBidWZmZXJzIGNhbiBiZSBpbiBvbmUgb2YgNiBzdGF0ZXM6CiAgKglBUkNf YW5vbgktIGFub255bW91cyAoZGlzY3Vzc2VkIGJlbG93KQpAQCAtMjQxOCw5ICsyNDU4LDEyIEBA IGFyY19mbHVzaChzcGFfdCAqc3BhKQogdm9pZAogYXJjX3Nocmluayh2b2lkKQogeworCiAJaWYg KGFyY19jID4gYXJjX2NfbWluKSB7CiAJCXVpbnQ2NF90IHRvX2ZyZWU7CiAKKwkJRFRSQUNFX1BS T0JFMihhcmNfX3NocmluaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRfdCwKKwkJCWFyY19jX21p bik7CiAjaWZkZWYgX0tFUk5FTAogCQl0b19mcmVlID0gYXJjX2MgPj4gYXJjX3Nocmlua19zaGlm dDsKICNlbHNlCkBAIC0yNDQwLDggKzI0ODMsMTEgQEAgYXJjX3Nocmluayh2b2lkKQogCQlBU1NF UlQoKGludDY0X3QpYXJjX3AgPj0gMCk7CiAJfQogCi0JaWYgKGFyY19zaXplID4gYXJjX2MpCisJ aWYgKGFyY19zaXplID4gYXJjX2MpIHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3Nocmlua19hZGp1 c3QsIHVpbnQ2NF90LCBhcmNfc2l6ZSwKKwkJCXVpbnQ2NF90LCBhcmNfYyk7CiAJCWFyY19hZGp1 c3QoKTsKKwl9CiB9CiAKIHN0YXRpYyBpbnQgbmVlZGZyZWUgPSAwOwpAQCAtMjQ1MiwxNSArMjQ5 OCwyNSBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIAogI2lmZGVmIF9LRVJORUwKIAotCWlm IChuZWVkZnJlZSkKKwlpZiAobmVlZGZyZWUpIHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFp bV9uZWVkZnJlZSk7CiAJCXJldHVybiAoMSk7CisJfQogCisJaWYgKGttZW1fZnJlZV9jb3VudCgp IDwgemZzX2FyY19mcmVlX3RhcmdldCkgeworCQlEVFJBQ0VfUFJPQkUyKGFyY19fcmVjbGFpbV9m cmVldGFyZ2V0LCB1aW50NjRfdCwKKwkJICAgIGttZW1fZnJlZV9jb3VudCgpLCB1aW50NjRfdCwg emZzX2FyY19mcmVlX3RhcmdldCk7CisJCXJldHVybiAoMSk7CisJfQorCiAJLyoKIAkgKiBDb29w ZXJhdGUgd2l0aCBwYWdlZGFlbW9uIHdoZW4gaXQncyB0aW1lIGZvciBpdCB0byBzY2FuCiAJICog YW5kIHJlY2xhaW0gc29tZSBwYWdlcy4KIAkgKi8KLQlpZiAodm1fcGFnaW5nX25lZWRlZCgpKQor CWlmICh2bV9wYWdpbmdfbmVlZGVkKCkpIHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9w YWdpbmcpOwogCQlyZXR1cm4gKDEpOworCX0KIAogI2lmZGVmIHN1bgogCS8qCkBAIC0yNTA0LDkg KzI1NjAsNiBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIAkgICAgKGJ0b3Aodm1lbV9zaXpl KGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+PiAyKSkKIAkJcmV0dXJuICgx KTsKICNlbmRpZgotI2Vsc2UJLyogIXN1biAqLwotCWlmIChrbWVtX3VzZWQoKSA+IChrbWVtX3Np emUoKSAqIDMpIC8gNCkKLQkJcmV0dXJuICgxKTsKICNlbmRpZgkvKiBzdW4gKi8KIAogI2Vsc2UK QEAgLTI1MTMsNiArMjU2Niw4IEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogCWlmIChzcGFf Z2V0X3JhbmRvbSgxMDApID09IDApCiAJCXJldHVybiAoMSk7CiAjZW5kaWYKKwlEVFJBQ0VfUFJP QkUoYXJjX19yZWNsYWltX25vKTsKKwogCXJldHVybiAoMCk7CiB9CiAKSW5kZXg6IHN5cy92bS92 bV9wYWdlb3V0LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkocmV2aXNpb24g MjcwNDIyKQorKysgc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkod29ya2luZyBjb3B5KQpAQCAtMTE1LDEw ICsxMTUsMTQgQEAgX19GQlNESUQoIiRGcmVlQlNEJCIpOwogCiAvKiB0aGUga2VybmVsIHByb2Nl c3MgInZtX3BhZ2VvdXQiKi8KIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXQodm9pZCk7CitzdGF0aWMg dm9pZCB2bV9wYWdlb3V0X2luaXQodm9pZCk7CiBzdGF0aWMgaW50IHZtX3BhZ2VvdXRfY2xlYW4o dm1fcGFnZV90KTsKIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXRfc2NhbihzdHJ1Y3Qgdm1fZG9tYWlu ICp2bWQsIGludCBwYXNzKTsKIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXRfbWlnaHRiZV9vb20oc3Ry dWN0IHZtX2RvbWFpbiAqdm1kLCBpbnQgcGFzcyk7CiAKK1NZU0lOSVQocGFnZWRhZW1vbl9pbml0 LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9GSVJTVCwgdm1fcGFnZW91dF9pbml0LAor ICAgIE5VTEwpOworCiBzdHJ1Y3QgcHJvYyAqcGFnZXByb2M7CiAKIHN0YXRpYyBzdHJ1Y3Qga3By b2NfZGVzYyBwYWdlX2twID0gewpAQCAtMTI2LDcgKzEzMCw3IEBAIHN0YXRpYyBzdHJ1Y3Qga3By b2NfZGVzYyBwYWdlX2twID0gewogCXZtX3BhZ2VvdXQsCiAJJnBhZ2Vwcm9jCiB9OwotU1lTSU5J VChwYWdlZGFlbW9uLCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9GSVJTVCwga3Byb2Nf c3RhcnQsCitTWVNJTklUKHBhZ2VkYWVtb24sIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVS X1NFQ09ORCwga3Byb2Nfc3RhcnQsCiAgICAgJnBhZ2Vfa3ApOwogCiAjaWYgIWRlZmluZWQoTk9f U1dBUFBJTkcpCkBAIC0xNjM3LDE1ICsxNjQxLDExIEBAIHZtX3BhZ2VvdXRfd29ya2VyKHZvaWQg KmFyZykKIH0KIAogLyoKLSAqCXZtX3BhZ2VvdXQgaXMgdGhlIGhpZ2ggbGV2ZWwgcGFnZW91dCBk YWVtb24uCisgKgl2bV9wYWdlb3V0X2luaXQgaW5pdGlhbGlzZXMgYmFzaWMgcGFnZW91dCBkYWVt b24gc2V0dGluZ3MuCiAgKi8KIHN0YXRpYyB2b2lkCi12bV9wYWdlb3V0KHZvaWQpCit2bV9wYWdl b3V0X2luaXQodm9pZCkKIHsKLSNpZiBNQVhNRU1ET00gPiAxCi0JaW50IGVycm9yLCBpOwotI2Vu ZGlmCi0KIAkvKgogCSAqIEluaXRpYWxpemUgc29tZSBwYWdpbmcgcGFyYW1ldGVycy4KIAkgKi8K QEAgLTE2OTEsNyArMTY5MSwxOCBAQCBzdGF0aWMgdm9pZAogCS8qIFhYWCBkb2VzIG5vdCByZWFs bHkgYmVsb25nIGhlcmUgKi8KIAlpZiAodm1fcGFnZV9tYXhfd2lyZWQgPT0gMCkKIAkJdm1fcGFn ZV9tYXhfd2lyZWQgPSB2bV9jbnQudl9mcmVlX2NvdW50IC8gMzsKK30KIAorLyoKKyAqICAgICB2 bV9wYWdlb3V0IGlzIHRoZSBoaWdoIGxldmVsIHBhZ2VvdXQgZGFlbW9uLgorICovCitzdGF0aWMg dm9pZAordm1fcGFnZW91dCh2b2lkKQoreworI2lmIE1BWE1FTURPTSA+IDEKKwlpbnQgZXJyb3Is IGk7CisjZW5kaWYKKwogCXN3YXBfcGFnZXJfc3dhcF9pbml0KCk7CiAjaWYgTUFYTUVNRE9NID4g MQogCWZvciAoaSA9IDE7IGkgPCB2bV9uZG9tYWluczsgaSsrKSB7Cg== 146424 2014-08-27 23:18:01 +0000 2014-09-04 18:44:18 +0000 arc reclaim refactor (against head) arc-reclaim-head.patch text/plain 7507 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MDQyMikKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTI2LDE4ICsx MjYsNDcgQEAga21lbV9zaXplX2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQogfQogU1lTSU5J VChrbWVtX3NpemVfaW5pdCwgU0lfU1VCX0tNRU0sIFNJX09SREVSX0FOWSwga21lbV9zaXplX2lu aXQsIE5VTEwpOwogCi11aW50NjRfdAota21lbV9zaXplKHZvaWQpCisvKgorICogVGhlIHJldHVy biB2YWx1ZXMgZnJvbSBrbWVtX2ZyZWVfKiBhcmUgb25seSB2YWxpZCBvbmNlIHRoZSBwYWdlZGFl bW9uCisgKiBoYXMgYmVlbiBpbml0aWFsaXNlZCwgYmVmb3JlIHRoZW4gdGhleSByZXR1cm4gMC4K KyAqIAorICogVG8gZW5zdXJlIHRoZSByZXR1cm5zIGFyZSB2YWxpZCB0aGUgY2FsbGVyIGNhbiB1 c2UgYSBTWVNJTklUIHdpdGgKKyAqIHN1YnN5c3RlbSBzZXQgdG8gU0lfU1VCX0tUSFJFQURfUEFH RSBhbmQgYW4gb3JkZXIgb2YgYXQgbGVhc3QKKyAqIFNJX09SREVSX1NFQ09ORC4KKyAqLwordV9p bnQKK2ttZW1fZnJlZV90YXJnZXQodm9pZCkKIHsKIAotCXJldHVybiAoa21lbV9zaXplX3ZhbCk7 CisJcmV0dXJuICh2bV9jbnQudl9mcmVlX3RhcmdldCk7CiB9CiAKK3VfaW50CitrbWVtX2ZyZWVf bWluKHZvaWQpCit7CisKKwlyZXR1cm4gKHZtX2NudC52X2ZyZWVfbWluKTsKK30KKwordV9pbnQK K2ttZW1fZnJlZV9jb3VudCh2b2lkKQoreworCisJcmV0dXJuICh2bV9jbnQudl9mcmVlX2NvdW50 KTsKK30KKwordV9pbnQKK2ttZW1fcGFnZV9jb3VudCh2b2lkKQoreworCisJcmV0dXJuICh2bV9j bnQudl9wYWdlX2NvdW50KTsKK30KKwogdWludDY0X3QKLWttZW1fdXNlZCh2b2lkKQora21lbV9z aXplKHZvaWQpCiB7CiAKLQlyZXR1cm4gKHZtZW1fc2l6ZShrbWVtX2FyZW5hLCBWTUVNX0FMTE9D KSk7CisJcmV0dXJuIChrbWVtX3NpemVfdmFsKTsKIH0KIAogc3RhdGljIGludApJbmRleDogc3lz L2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2Nk ZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgJKHJldmlzaW9uIDI3MDQyMikKKysrIHN5 cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCSh3b3JraW5nIGNvcHkpCkBAIC02 Niw3ICs2NiwxNiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZvaWQgKnpmc19rbWVt X2FsbG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19rbWVtX2ZyZWUodm9p ZCAqYnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9pZCk7Ci11aW50NjRf dCBrbWVtX3VzZWQodm9pZCk7Cit1X2ludCBrbWVtX3BhZ2VfY291bnQodm9pZCk7CisKKy8qCisg KiBUaGUgcmV0dXJuIHZhbHVlcyBmcm9tIGttZW1fZnJlZV8qIGFyZSBvbmx5IHZhbGlkIG9uY2Ug dGhlIHBhZ2VkYWVtb24KKyAqIGhhcyBiZWVuIGluaXRpYWxpc2VkLCBiZWZvcmUgdGhlbiB0aGV5 IHJldHVybiAwLgorICovCit1X2ludCBrbWVtX2ZyZWVfY291bnQodm9pZCk7Cit1X2ludCBrbWVt X2ZyZWVfdGFyZ2V0KHZvaWQpOwordV9pbnQga21lbV9mcmVlX21pbih2b2lkKTsKKwoga21lbV9j YWNoZV90ICprbWVtX2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3QgYnVmc2l6ZSwgc2l6 ZV90IGFsaWduLAogICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZvaWQgKiwgaW50KSwg dm9pZCAoKmRlc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lkICgqcmVjbGFpbSko dm9pZCAqKSBfX3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAsIGludCBjZmxhZ3Mp OwpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9h cmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21t b24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzA0MjIpCisrKyBzeXMvY2RkbC9jb250cmliL29w ZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3b3JraW5nIGNvcHkpCkBAIC0xOTMs OSArMTkzLDYgQEAgZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hfZGlzYWJsZTsKICAqLwogc3RhdGlj IGJvb2xlYW5fdCBhcmNfd2FybTsKIAotLyoKLSAqIFRoZXNlIHR1bmFibGVzIGFyZSBmb3IgcGVy Zm9ybWFuY2UgYW5hbHlzaXMuCi0gKi8KIHVpbnQ2NF90IHpmc19hcmNfbWF4OwogdWludDY0X3Qg emZzX2FyY19taW47CiB1aW50NjRfdCB6ZnNfYXJjX21ldGFfbGltaXQgPSAwOwpAQCAtMjA0LDcg KzIwMSwyMSBAQCBpbnQgemZzX2FyY19zaHJpbmtfc2hpZnQgPSAwOwogaW50IHpmc19hcmNfcF9t aW5fc2hpZnQgPSAwOwogaW50IHpmc19kaXNhYmxlX2R1cF9ldmljdGlvbiA9IDA7CiB1aW50NjRf dCB6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEwMjQ7IC8qIDhLQiAqLwordV9pbnQg emZzX2FyY19mcmVlX3RhcmdldCA9ICgxIDw8IDE5KTsgLyogZGVmYXVsdCBiZWZvcmUgcGFnZWRh ZW1vbiBpbml0IG9ubHkgKi8KIAorc3RhdGljIGludCBzeXNjdGxfdmZzX3pmc19hcmNfZnJlZV90 YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CisKKyNpZmRlZiBfS0VSTkVMCitzdGF0aWMgdm9p ZAorYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQoreworCisJemZz X2FyY19mcmVlX3RhcmdldCA9IGttZW1fZnJlZV90YXJnZXQoKTsKK30KK1NZU0lOSVQoYXJjX2Zy ZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX0FOWSwKKyAgICBh cmNfZnJlZV90YXJnZXRfaW5pdCwgTlVMTCk7CisjZW5kaWYKKwogVFVOQUJMRV9RVUFEKCJ2ZnMu emZzLmFyY19tZXRhX2xpbWl0IiwgJnpmc19hcmNfbWV0YV9saW1pdCk7CiBTWVNDVExfREVDTChf dmZzX3pmcyk7CiBTWVNDVExfVVFVQUQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfbWF4LCBDVExG TEFHX1JEVFVOLCAmemZzX2FyY19tYXgsIDAsCkBAIC0yMTQsNyArMjI1LDM2IEBAIFNZU0NUTF9V UVVBRChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19taW4sIENUTEZMQUdfCiBTWVNDVExfVVFVQUQo X3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfYXZlcmFnZV9ibG9ja3NpemUsIENUTEZMQUdfUkRUVU4s CiAgICAgJnpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUsIDAsCiAgICAgIkFSQyBhdmVyYWdlIGJs b2Nrc2l6ZSIpOworLyoKKyAqIFdlIGRvbid0IGhhdmUgYSB0dW5hYmxlIGZvciBhcmNfZnJlZV90 YXJnZXQgZHVlIHRvIHRoZSBkZXBlbmRlbmN5IG9uCisgKiBwYWdlZGFlbW9uIGluaXRpYWxpc2F0 aW9uLgorICovCitTWVNDVExfUFJPQyhfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19mcmVlX3Rhcmdl dCwKKyAgICBDVExUWVBFX1VJTlQgfCBDVExGTEFHX01QU0FGRSB8IENUTEZMQUdfUlcsIDAsIHNp emVvZih1X2ludCksCisgICAgc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0LCAiSVUiLAor ICAgICJEZXNpcmVkIG51bWJlciBvZiBmcmVlIHBhZ2VzIGJlbG93IHdoaWNoIEFSQyB0cmlnZ2Vy cyByZWNsYWltIik7CiAKK3N0YXRpYyBpbnQKK3N5c2N0bF92ZnNfemZzX2FyY19mcmVlX3Rhcmdl dChTWVNDVExfSEFORExFUl9BUkdTKQoreworCXVfaW50IHZhbDsKKwlpbnQgZXJyOworCisJdmFs ID0gemZzX2FyY19mcmVlX3RhcmdldDsKKwllcnIgPSBzeXNjdGxfaGFuZGxlX2ludChvaWRwLCAm dmFsLCAwLCByZXEpOworCWlmIChlcnIgIT0gMCB8fCByZXEtPm5ld3B0ciA9PSBOVUxMKQorCQly ZXR1cm4gKGVycik7CisKKwlpZiAodmFsIDwga21lbV9mcmVlX21pbigpKQorCQlyZXR1cm4gKEVJ TlZBTCk7CisJaWYgKHZhbCA+IGttZW1fcGFnZV9jb3VudCgpKQorCQlyZXR1cm4gKEVJTlZBTCk7 CisKKwl6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gdmFsOworCisJcmV0dXJuICgwKTsKK30KKwogLyoK ICAqIE5vdGUgdGhhdCBidWZmZXJzIGNhbiBiZSBpbiBvbmUgb2YgNiBzdGF0ZXM6CiAgKglBUkNf YW5vbgktIGFub255bW91cyAoZGlzY3Vzc2VkIGJlbG93KQpAQCAtMjQxOCw5ICsyNDU4LDEyIEBA IGFyY19mbHVzaChzcGFfdCAqc3BhKQogdm9pZAogYXJjX3Nocmluayh2b2lkKQogeworCiAJaWYg KGFyY19jID4gYXJjX2NfbWluKSB7CiAJCXVpbnQ2NF90IHRvX2ZyZWU7CiAKKwkJRFRSQUNFX1BS T0JFMihhcmNfX3NocmluaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRfdCwKKwkJCWFyY19jX21p bik7CiAjaWZkZWYgX0tFUk5FTAogCQl0b19mcmVlID0gYXJjX2MgPj4gYXJjX3Nocmlua19zaGlm dDsKICNlbHNlCkBAIC0yNDQwLDggKzI0ODMsMTEgQEAgYXJjX3Nocmluayh2b2lkKQogCQlBU1NF UlQoKGludDY0X3QpYXJjX3AgPj0gMCk7CiAJfQogCi0JaWYgKGFyY19zaXplID4gYXJjX2MpCisJ aWYgKGFyY19zaXplID4gYXJjX2MpIHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3Nocmlua19hZGp1 c3QsIHVpbnQ2NF90LCBhcmNfc2l6ZSwKKwkJCXVpbnQ2NF90LCBhcmNfYyk7CiAJCWFyY19hZGp1 c3QoKTsKKwl9CiB9CiAKIHN0YXRpYyBpbnQgbmVlZGZyZWUgPSAwOwpAQCAtMjQ1MiwxNSArMjQ5 OCwyNSBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIAogI2lmZGVmIF9LRVJORUwKIAotCWlm IChuZWVkZnJlZSkKKwlpZiAobmVlZGZyZWUpIHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFp bV9uZWVkZnJlZSk7CiAJCXJldHVybiAoMSk7CisJfQogCisJaWYgKGttZW1fZnJlZV9jb3VudCgp IDwgemZzX2FyY19mcmVlX3RhcmdldCkgeworCQlEVFJBQ0VfUFJPQkUyKGFyY19fcmVjbGFpbV9m cmVldGFyZ2V0LCB1aW50NjRfdCwKKwkJICAgIGttZW1fZnJlZV9jb3VudCgpLCB1aW50NjRfdCwg emZzX2FyY19mcmVlX3RhcmdldCk7CisJCXJldHVybiAoMSk7CisJfQorCiAJLyoKIAkgKiBDb29w ZXJhdGUgd2l0aCBwYWdlZGFlbW9uIHdoZW4gaXQncyB0aW1lIGZvciBpdCB0byBzY2FuCiAJICog YW5kIHJlY2xhaW0gc29tZSBwYWdlcy4KIAkgKi8KLQlpZiAodm1fcGFnaW5nX25lZWRlZCgpKQor CWlmICh2bV9wYWdpbmdfbmVlZGVkKCkpIHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9w YWdpbmcpOwogCQlyZXR1cm4gKDEpOworCX0KIAogI2lmZGVmIHN1bgogCS8qCkBAIC0yNTA0LDkg KzI1NjAsNiBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIAkgICAgKGJ0b3Aodm1lbV9zaXpl KGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+PiAyKSkKIAkJcmV0dXJuICgx KTsKICNlbmRpZgotI2Vsc2UJLyogIXN1biAqLwotCWlmIChrbWVtX3VzZWQoKSA+IChrbWVtX3Np emUoKSAqIDMpIC8gNCkKLQkJcmV0dXJuICgxKTsKICNlbmRpZgkvKiBzdW4gKi8KIAogI2Vsc2UK QEAgLTI1MTMsNiArMjU2Niw4IEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogCWlmIChzcGFf Z2V0X3JhbmRvbSgxMDApID09IDApCiAJCXJldHVybiAoMSk7CiAjZW5kaWYKKwlEVFJBQ0VfUFJP QkUoYXJjX19yZWNsYWltX25vKTsKKwogCXJldHVybiAoMCk7CiB9CiAKSW5kZXg6IHN5cy92bS92 bV9wYWdlb3V0LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkocmV2aXNpb24g MjcwNDIyKQorKysgc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkod29ya2luZyBjb3B5KQpAQCAtMTE1LDEw ICsxMTUsMTQgQEAgX19GQlNESUQoIiRGcmVlQlNEJCIpOwogCiAvKiB0aGUga2VybmVsIHByb2Nl c3MgInZtX3BhZ2VvdXQiKi8KIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXQodm9pZCk7CitzdGF0aWMg dm9pZCB2bV9wYWdlb3V0X2luaXQodm9pZCk7CiBzdGF0aWMgaW50IHZtX3BhZ2VvdXRfY2xlYW4o dm1fcGFnZV90KTsKIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXRfc2NhbihzdHJ1Y3Qgdm1fZG9tYWlu ICp2bWQsIGludCBwYXNzKTsKIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXRfbWlnaHRiZV9vb20oc3Ry dWN0IHZtX2RvbWFpbiAqdm1kLCBpbnQgcGFzcyk7CiAKK1NZU0lOSVQocGFnZWRhZW1vbl9pbml0 LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9GSVJTVCwgdm1fcGFnZW91dF9pbml0LAor ICAgIE5VTEwpOworCiBzdHJ1Y3QgcHJvYyAqcGFnZXByb2M7CiAKIHN0YXRpYyBzdHJ1Y3Qga3By b2NfZGVzYyBwYWdlX2twID0gewpAQCAtMTI2LDcgKzEzMCw3IEBAIHN0YXRpYyBzdHJ1Y3Qga3By b2NfZGVzYyBwYWdlX2twID0gewogCXZtX3BhZ2VvdXQsCiAJJnBhZ2Vwcm9jCiB9OwotU1lTSU5J VChwYWdlZGFlbW9uLCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9GSVJTVCwga3Byb2Nf c3RhcnQsCitTWVNJTklUKHBhZ2VkYWVtb24sIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVS X1NFQ09ORCwga3Byb2Nfc3RhcnQsCiAgICAgJnBhZ2Vfa3ApOwogCiAjaWYgIWRlZmluZWQoTk9f U1dBUFBJTkcpCkBAIC0xNjM3LDE1ICsxNjQxLDExIEBAIHZtX3BhZ2VvdXRfd29ya2VyKHZvaWQg KmFyZykKIH0KIAogLyoKLSAqCXZtX3BhZ2VvdXQgaXMgdGhlIGhpZ2ggbGV2ZWwgcGFnZW91dCBk YWVtb24uCisgKgl2bV9wYWdlb3V0X2luaXQgaW5pdGlhbGlzZXMgYmFzaWMgcGFnZW91dCBkYWVt b24gc2V0dGluZ3MuCiAgKi8KIHN0YXRpYyB2b2lkCi12bV9wYWdlb3V0KHZvaWQpCit2bV9wYWdl b3V0X2luaXQodm9pZCkKIHsKLSNpZiBNQVhNRU1ET00gPiAxCi0JaW50IGVycm9yLCBpOwotI2Vu ZGlmCi0KIAkvKgogCSAqIEluaXRpYWxpemUgc29tZSBwYWdpbmcgcGFyYW1ldGVycy4KIAkgKi8K QEAgLTE2OTEsNyArMTY5MSwxOCBAQCBzdGF0aWMgdm9pZAogCS8qIFhYWCBkb2VzIG5vdCByZWFs bHkgYmVsb25nIGhlcmUgKi8KIAlpZiAodm1fcGFnZV9tYXhfd2lyZWQgPT0gMCkKIAkJdm1fcGFn ZV9tYXhfd2lyZWQgPSB2bV9jbnQudl9mcmVlX2NvdW50IC8gMzsKK30KIAorLyoKKyAqICAgICB2 bV9wYWdlb3V0IGlzIHRoZSBoaWdoIGxldmVsIHBhZ2VvdXQgZGFlbW9uLgorICovCitzdGF0aWMg dm9pZAordm1fcGFnZW91dCh2b2lkKQoreworI2lmIE1BWE1FTURPTSA+IDEKKwlpbnQgZXJyb3Is IGk7CisjZW5kaWYKKwogCXN3YXBfcGFnZXJfc3dhcF9pbml0KCk7CiAjaWYgTUFYTUVNRE9NID4g MQogCWZvciAoaSA9IDE7IGkgPCB2bV9uZG9tYWluczsgaSsrKSB7Cg== 146456 2014-08-28 15:19:36 +0000 2014-09-04 18:42:10 +0000 arc reclaim refactor (against stable/10) arc-reclaim-stable10.patch text/plain 7665 junchoon SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MDQyMikKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTI2LDE4ICsx MjYsNDcgQEAga21lbV9zaXplX2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQogfQogU1lTSU5J VChrbWVtX3NpemVfaW5pdCwgU0lfU1VCX0tNRU0sIFNJX09SREVSX0FOWSwga21lbV9zaXplX2lu aXQsIE5VTEwpOwogCi11aW50NjRfdAota21lbV9zaXplKHZvaWQpCisvKgorICogVGhlIHJldHVy biB2YWx1ZXMgZnJvbSBrbWVtX2ZyZWVfKiBhcmUgb25seSB2YWxpZCBvbmNlIHRoZSBwYWdlZGFl bW9uCisgKiBoYXMgYmVlbiBpbml0aWFsaXNlZCwgYmVmb3JlIHRoZW4gdGhleSByZXR1cm4gMC4K KyAqIAorICogVG8gZW5zdXJlIHRoZSByZXR1cm5zIGFyZSB2YWxpZCB0aGUgY2FsbGVyIGNhbiB1 c2UgYSBTWVNJTklUIHdpdGgKKyAqIHN1YnN5c3RlbSBzZXQgdG8gU0lfU1VCX0tUSFJFQURfUEFH RSBhbmQgYW4gb3JkZXIgb2YgYXQgbGVhc3QKKyAqIFNJX09SREVSX1NFQ09ORC4KKyAqLwordV9p bnQKK2ttZW1fZnJlZV90YXJnZXQodm9pZCkKIHsKIAotCXJldHVybiAoa21lbV9zaXplX3ZhbCk7 CisJcmV0dXJuIChjbnQudl9mcmVlX3RhcmdldCk7CiB9CiAKK3VfaW50CitrbWVtX2ZyZWVfbWlu KHZvaWQpCit7CisKKwlyZXR1cm4gKGNudC52X2ZyZWVfbWluKTsKK30KKwordV9pbnQKK2ttZW1f ZnJlZV9jb3VudCh2b2lkKQoreworCisJcmV0dXJuIChjbnQudl9mcmVlX2NvdW50KTsKK30KKwor dV9pbnQKK2ttZW1fcGFnZV9jb3VudCh2b2lkKQoreworCisJcmV0dXJuIChjbnQudl9wYWdlX2Nv dW50KTsKK30KKwogdWludDY0X3QKLWttZW1fdXNlZCh2b2lkKQora21lbV9zaXplKHZvaWQpCiB7 CiAKLQlyZXR1cm4gKHZtZW1fc2l6ZShrbWVtX2FyZW5hLCBWTUVNX0FMTE9DKSk7CisJcmV0dXJu IChrbWVtX3NpemVfdmFsKTsKIH0KIAogc3RhdGljIGludApJbmRleDogc3lzL2NkZGwvY29tcGF0 L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29tcGF0L29w ZW5zb2xhcmlzL3N5cy9rbWVtLmgJKHJldmlzaW9uIDI3MDQyMikKKysrIHN5cy9jZGRsL2NvbXBh dC9vcGVuc29sYXJpcy9zeXMva21lbS5oCSh3b3JraW5nIGNvcHkpCkBAIC02Niw3ICs2NiwxNiBA QCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZvaWQgKnpmc19rbWVtX2FsbG9jKHNpemVf dCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19rbWVtX2ZyZWUodm9pZCAqYnVmLCBzaXpl X3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9pZCk7Ci11aW50NjRfdCBrbWVtX3VzZWQo dm9pZCk7Cit1X2ludCBrbWVtX3BhZ2VfY291bnQodm9pZCk7CisKKy8qCisgKiBUaGUgcmV0dXJu IHZhbHVlcyBmcm9tIGttZW1fZnJlZV8qIGFyZSBvbmx5IHZhbGlkIG9uY2UgdGhlIHBhZ2VkYWVt b24KKyAqIGhhcyBiZWVuIGluaXRpYWxpc2VkLCBiZWZvcmUgdGhlbiB0aGV5IHJldHVybiAwLgor ICovCit1X2ludCBrbWVtX2ZyZWVfY291bnQodm9pZCk7Cit1X2ludCBrbWVtX2ZyZWVfdGFyZ2V0 KHZvaWQpOwordV9pbnQga21lbV9mcmVlX21pbih2b2lkKTsKKwoga21lbV9jYWNoZV90ICprbWVt X2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3QgYnVmc2l6ZSwgc2l6ZV90IGFsaWduLAog ICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZvaWQgKiwgaW50KSwgdm9pZCAoKmRlc3Ry dWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lkICgqcmVjbGFpbSkodm9pZCAqKSBfX3Vu dXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAsIGludCBjZmxhZ3MpOwpJbmRleDogc3lz L2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2Fy Yy5jCShyZXZpc2lvbiAyNzA0MjIpCisrKyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0 cy9jb21tb24vZnMvemZzL2FyYy5jCSh3b3JraW5nIGNvcHkpCkBAIC0xOTMsOSArMTkzLDYgQEAg ZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hfZGlzYWJsZTsKICAqLwogc3RhdGljIGJvb2xlYW5fdCBh cmNfd2FybTsKIAotLyoKLSAqIFRoZXNlIHR1bmFibGVzIGFyZSBmb3IgcGVyZm9ybWFuY2UgYW5h bHlzaXMuCi0gKi8KIHVpbnQ2NF90IHpmc19hcmNfbWF4OwogdWludDY0X3QgemZzX2FyY19taW47 CiB1aW50NjRfdCB6ZnNfYXJjX21ldGFfbGltaXQgPSAwOwpAQCAtMjA0LDEwICsyMDEsMjQgQEAg aW50IHpmc19hcmNfc2hyaW5rX3NoaWZ0ID0gMDsKIGludCB6ZnNfYXJjX3BfbWluX3NoaWZ0ID0g MDsKIGludCB6ZnNfZGlzYWJsZV9kdXBfZXZpY3Rpb24gPSAwOwogdWludDY0X3QgemZzX2FyY19h dmVyYWdlX2Jsb2Nrc2l6ZSA9IDggKiAxMDI0OyAvKiA4S0IgKi8KK3VfaW50IHpmc19hcmNfZnJl ZV90YXJnZXQgPSAoMSA8PCAxOSk7IC8qIGRlZmF1bHQgYmVmb3JlIHBhZ2VkYWVtb24gaW5pdCBv bmx5ICovCiAKK3N0YXRpYyBpbnQgc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0KFNZU0NU TF9IQU5ETEVSX0FSR1MpOworCisjaWZkZWYgX0tFUk5FTAorc3RhdGljIHZvaWQKK2FyY19mcmVl X3RhcmdldF9pbml0KHZvaWQgKnVudXNlZCBfX3VudXNlZCkKK3sKKworCXpmc19hcmNfZnJlZV90 YXJnZXQgPSBrbWVtX2ZyZWVfdGFyZ2V0KCk7Cit9CitTWVNJTklUKGFyY19mcmVlX3RhcmdldF9p bml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9BTlksCisgICAgYXJjX2ZyZWVfdGFy Z2V0X2luaXQsIE5VTEwpOworI2VuZGlmCisKIFRVTkFCTEVfUVVBRCgidmZzLnpmcy5hcmNfbWF4 IiwgJnpmc19hcmNfbWF4KTsKIFRVTkFCTEVfUVVBRCgidmZzLnpmcy5hcmNfbWluIiwgJnpmc19h cmNfbWluKTsKIFRVTkFCTEVfUVVBRCgidmZzLnpmcy5hcmNfbWV0YV9saW1pdCIsICZ6ZnNfYXJj X21ldGFfbGltaXQpOwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19hdmVyYWdlX2Jsb2Nrc2l6 ZSIsICZ6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplKTsKIFNZU0NUTF9ERUNMKF92ZnNfemZzKTsK IFNZU0NUTF9VUVVBRChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19tYXgsIENUTEZMQUdfUkRUVU4s ICZ6ZnNfYXJjX21heCwgMCwKQEAgLTIxNyw3ICsyMjgsMzYgQEAgU1lTQ1RMX1VRVUFEKF92ZnNf emZzLCBPSURfQVVUTywgYXJjX21pbiwgQ1RMRkxBR18KIFNZU0NUTF9VUVVBRChfdmZzX3pmcywg T0lEX0FVVE8sIGFyY19hdmVyYWdlX2Jsb2Nrc2l6ZSwgQ1RMRkxBR19SRFRVTiwKICAgICAmemZz X2FyY19hdmVyYWdlX2Jsb2Nrc2l6ZSwgMCwKICAgICAiQVJDIGF2ZXJhZ2UgYmxvY2tzaXplIik7 CisvKgorICogV2UgZG9uJ3QgaGF2ZSBhIHR1bmFibGUgZm9yIGFyY19mcmVlX3RhcmdldCBkdWUg dG8gdGhlIGRlcGVuZGVuY3kgb24KKyAqIHBhZ2VkYWVtb24gaW5pdGlhbGlzYXRpb24uCisgKi8K K1NZU0NUTF9QUk9DKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2ZyZWVfdGFyZ2V0LAorICAgIENU TFRZUEVfVUlOVCB8IENUTEZMQUdfTVBTQUZFIHwgQ1RMRkxBR19SVywgMCwgc2l6ZW9mKHVfaW50 KSwKKyAgICBzeXNjdGxfdmZzX3pmc19hcmNfZnJlZV90YXJnZXQsICJJVSIsCisgICAgIkRlc2ly ZWQgbnVtYmVyIG9mIGZyZWUgcGFnZXMgYmVsb3cgd2hpY2ggQVJDIHRyaWdnZXJzIHJlY2xhaW0i KTsKIAorc3RhdGljIGludAorc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0KFNZU0NUTF9I QU5ETEVSX0FSR1MpCit7CisJdV9pbnQgdmFsOworCWludCBlcnI7CisKKwl2YWwgPSB6ZnNfYXJj X2ZyZWVfdGFyZ2V0OworCWVyciA9IHN5c2N0bF9oYW5kbGVfaW50KG9pZHAsICZ2YWwsIDAsIHJl cSk7CisJaWYgKGVyciAhPSAwIHx8IHJlcS0+bmV3cHRyID09IE5VTEwpCisJCXJldHVybiAoZXJy KTsKKworCWlmICh2YWwgPCBrbWVtX2ZyZWVfbWluKCkpCisJCXJldHVybiAoRUlOVkFMKTsKKwlp ZiAodmFsID4ga21lbV9wYWdlX2NvdW50KCkpCisJCXJldHVybiAoRUlOVkFMKTsKKworCXpmc19h cmNfZnJlZV90YXJnZXQgPSB2YWw7CisKKwlyZXR1cm4gKDApOworfQorCiAvKgogICogTm90ZSB0 aGF0IGJ1ZmZlcnMgY2FuIGJlIGluIG9uZSBvZiA2IHN0YXRlczoKICAqCUFSQ19hbm9uCS0gYW5v bnltb3VzIChkaXNjdXNzZWQgYmVsb3cpCkBAIC0yNDIxLDkgKzI0NjEsMTIgQEAgYXJjX2ZsdXNo KHNwYV90ICpzcGEpCiB2b2lkCiBhcmNfc2hyaW5rKHZvaWQpCiB7CisKIAlpZiAoYXJjX2MgPiBh cmNfY19taW4pIHsKIAkJdWludDY0X3QgdG9fZnJlZTsKIAorCQlEVFJBQ0VfUFJPQkUyKGFyY19f c2hyaW5rLCB1aW50NjRfdCwgYXJjX2MsIHVpbnQ2NF90LAorCQkJYXJjX2NfbWluKTsKICNpZmRl ZiBfS0VSTkVMCiAJCXRvX2ZyZWUgPSBhcmNfYyA+PiBhcmNfc2hyaW5rX3NoaWZ0OwogI2Vsc2UK QEAgLTI0NDMsOCArMjQ4NiwxMSBAQCBhcmNfc2hyaW5rKHZvaWQpCiAJCUFTU0VSVCgoaW50NjRf dClhcmNfcCA+PSAwKTsKIAl9CiAKLQlpZiAoYXJjX3NpemUgPiBhcmNfYykKKwlpZiAoYXJjX3Np emUgPiBhcmNfYykgeworCQlEVFJBQ0VfUFJPQkUyKGFyY19fc2hyaW5rX2FkanVzdCwgdWludDY0 X3QsIGFyY19zaXplLAorCQkJdWludDY0X3QsIGFyY19jKTsKIAkJYXJjX2FkanVzdCgpOworCX0K IH0KIAogc3RhdGljIGludCBuZWVkZnJlZSA9IDA7CkBAIC0yNDU1LDE1ICsyNTAxLDI1IEBAIGFy Y19yZWNsYWltX25lZWRlZCh2b2lkKQogCiAjaWZkZWYgX0tFUk5FTAogCi0JaWYgKG5lZWRmcmVl KQorCWlmIChuZWVkZnJlZSkgeworCQlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX25lZWRmcmVl KTsKIAkJcmV0dXJuICgxKTsKKwl9CiAKKwlpZiAoa21lbV9mcmVlX2NvdW50KCkgPCB6ZnNfYXJj X2ZyZWVfdGFyZ2V0KSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19yZWNsYWltX2ZyZWV0YXJnZXQs IHVpbnQ2NF90LAorCQkgICAga21lbV9mcmVlX2NvdW50KCksIHVpbnQ2NF90LCB6ZnNfYXJjX2Zy ZWVfdGFyZ2V0KTsKKwkJcmV0dXJuICgxKTsKKwl9CisKIAkvKgogCSAqIENvb3BlcmF0ZSB3aXRo IHBhZ2VkYWVtb24gd2hlbiBpdCdzIHRpbWUgZm9yIGl0IHRvIHNjYW4KIAkgKiBhbmQgcmVjbGFp bSBzb21lIHBhZ2VzLgogCSAqLwotCWlmICh2bV9wYWdpbmdfbmVlZGVkKCkpCisJaWYgKHZtX3Bh Z2luZ19uZWVkZWQoKSkgeworCQlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX3BhZ2luZyk7CiAJ CXJldHVybiAoMSk7CisJfQogCiAjaWZkZWYgc3VuCiAJLyoKQEAgLTI1MDcsOSArMjU2Myw2IEBA IGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogCSAgICAoYnRvcCh2bWVtX3NpemUoaGVhcF9hcmVu YSwgVk1FTV9GUkVFIHwgVk1FTV9BTExPQykpID4+IDIpKQogCQlyZXR1cm4gKDEpOwogI2VuZGlm Ci0jZWxzZQkvKiAhc3VuICovCi0JaWYgKGttZW1fdXNlZCgpID4gKGttZW1fc2l6ZSgpICogMykg LyA0KQotCQlyZXR1cm4gKDEpOwogI2VuZGlmCS8qIHN1biAqLwogCiAjZWxzZQpAQCAtMjUxNiw2 ICsyNTY5LDggQEAgYXJjX3JlY2xhaW1fbmVlZGVkKHZvaWQpCiAJaWYgKHNwYV9nZXRfcmFuZG9t KDEwMCkgPT0gMCkKIAkJcmV0dXJuICgxKTsKICNlbmRpZgorCURUUkFDRV9QUk9CRShhcmNfX3Jl Y2xhaW1fbm8pOworCiAJcmV0dXJuICgwKTsKIH0KIApJbmRleDogc3lzL3ZtL3ZtX3BhZ2VvdXQu Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvdm0vdm1fcGFnZW91dC5jCShyZXZpc2lvbiAyNzA0MjIpCisr KyBzeXMvdm0vdm1fcGFnZW91dC5jCSh3b3JraW5nIGNvcHkpCkBAIC0xMTUsMTAgKzExNSwxNCBA QCBfX0ZCU0RJRCgiJEZyZWVCU0QkIik7CiAKIC8qIHRoZSBrZXJuZWwgcHJvY2VzcyAidm1fcGFn ZW91dCIqLwogc3RhdGljIHZvaWQgdm1fcGFnZW91dCh2b2lkKTsKK3N0YXRpYyB2b2lkIHZtX3Bh Z2VvdXRfaW5pdCh2b2lkKTsKIHN0YXRpYyBpbnQgdm1fcGFnZW91dF9jbGVhbih2bV9wYWdlX3Qp Owogc3RhdGljIHZvaWQgdm1fcGFnZW91dF9zY2FuKHN0cnVjdCB2bV9kb21haW4gKnZtZCwgaW50 IHBhc3MpOwogc3RhdGljIHZvaWQgdm1fcGFnZW91dF9taWdodGJlX29vbShzdHJ1Y3Qgdm1fZG9t YWluICp2bWQsIGludCBwYXNzKTsKIAorU1lTSU5JVChwYWdlZGFlbW9uX2luaXQsIFNJX1NVQl9L VEhSRUFEX1BBR0UsIFNJX09SREVSX0ZJUlNULCB2bV9wYWdlb3V0X2luaXQsCisgICAgTlVMTCk7 CisKIHN0cnVjdCBwcm9jICpwYWdlcHJvYzsKIAogc3RhdGljIHN0cnVjdCBrcHJvY19kZXNjIHBh Z2Vfa3AgPSB7CkBAIC0xMjYsNyArMTMwLDcgQEAgc3RhdGljIHN0cnVjdCBrcHJvY19kZXNjIHBh Z2Vfa3AgPSB7CiAJdm1fcGFnZW91dCwKIAkmcGFnZXByb2MKIH07Ci1TWVNJTklUKHBhZ2VkYWVt b24sIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX0ZJUlNULCBrcHJvY19zdGFydCwKK1NZ U0lOSVQocGFnZWRhZW1vbiwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfU0VDT05ELCBr cHJvY19zdGFydCwKICAgICAmcGFnZV9rcCk7CiAKICNpZiAhZGVmaW5lZChOT19TV0FQUElORykK QEAgLTE2MzcsMTUgKzE2NDEsMTEgQEAgdm1fcGFnZW91dF93b3JrZXIodm9pZCAqYXJnKQogfQog CiAvKgotICoJdm1fcGFnZW91dCBpcyB0aGUgaGlnaCBsZXZlbCBwYWdlb3V0IGRhZW1vbi4KKyAq CXZtX3BhZ2VvdXRfaW5pdCBpbml0aWFsaXNlcyBiYXNpYyBwYWdlb3V0IGRhZW1vbiBzZXR0aW5n cy4KICAqLwogc3RhdGljIHZvaWQKLXZtX3BhZ2VvdXQodm9pZCkKK3ZtX3BhZ2VvdXRfaW5pdCh2 b2lkKQogewotI2lmIE1BWE1FTURPTSA+IDEKLQlpbnQgZXJyb3IsIGk7Ci0jZW5kaWYKLQogCS8q CiAJICogSW5pdGlhbGl6ZSBzb21lIHBhZ2luZyBwYXJhbWV0ZXJzLgogCSAqLwpAQCAtMTY5MSw3 ICsxNjkxLDE4IEBAIHN0YXRpYyB2b2lkCiAJLyogWFhYIGRvZXMgbm90IHJlYWxseSBiZWxvbmcg aGVyZSAqLwogCWlmICh2bV9wYWdlX21heF93aXJlZCA9PSAwKQogCQl2bV9wYWdlX21heF93aXJl ZCA9IGNudC52X2ZyZWVfY291bnQgLyAzOworfQogCisvKgorICogICAgIHZtX3BhZ2VvdXQgaXMg dGhlIGhpZ2ggbGV2ZWwgcGFnZW91dCBkYWVtb24uCisgKi8KK3N0YXRpYyB2b2lkCit2bV9wYWdl b3V0KHZvaWQpCit7CisjaWYgTUFYTUVNRE9NID4gMQorCWludCBlcnJvciwgaTsKKyNlbmRpZgor CiAJc3dhcF9wYWdlcl9zd2FwX2luaXQoKTsKICNpZiBNQVhNRU1ET00gPiAxCiAJZm9yIChpID0g MTsgaSA8IHZtX25kb21haW5zOyBpKyspIHsK 146816 2014-09-04 18:42:10 +0000 2014-09-05 09:15:24 +0000 arc reclaim refactor (against stable/10) arc-reclaim-10.patch text/plain 9055 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MTExNikKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTMzLDEzICsx MzMsNiBAQCBrbWVtX3NpemUodm9pZCkKIAlyZXR1cm4gKGttZW1fc2l6ZV92YWwpOwogfQogCi11 aW50NjRfdAota21lbV91c2VkKHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtZW1fc2l6ZShrbWVtX2Fy ZW5hLCBWTUVNX0FMTE9DKSk7Ci19Ci0KIHN0YXRpYyBpbnQKIGttZW1fc3RkX2NvbnN0cnVjdG9y KHZvaWQgKm1lbSwgaW50IHNpemUgX191bnVzZWQsIHZvaWQgKnByaXZhdGUsIGludCBmbGFncykK IHsKSW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCShyZXZpc2lvbiAy NzExMTYpCisrKyBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMvc3lzL2ttZW0uaAkod29ya2lu ZyBjb3B5KQpAQCAtNjYsNyArNjYsNiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZv aWQgKnpmc19rbWVtX2FsbG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19r bWVtX2ZyZWUodm9pZCAqYnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9p ZCk7Ci11aW50NjRfdCBrbWVtX3VzZWQodm9pZCk7CiBrbWVtX2NhY2hlX3QgKmttZW1fY2FjaGVf Y3JlYXRlKGNoYXIgKm5hbWUsIHNpemVfdCBidWZzaXplLCBzaXplX3QgYWxpZ24sCiAgICAgaW50 ICgqY29uc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqLCBpbnQpLCB2b2lkICgqZGVzdHJ1Y3Rvciko dm9pZCAqLCB2b2lkICopLAogICAgIHZvaWQgKCpyZWNsYWltKSh2b2lkICopIF9fdW51c2VkLCB2 b2lkICpwcml2YXRlLCB2bWVtX3QgKnZtcCwgaW50IGNmbGFncyk7CkBAIC03OCw2ICs3Nyw5IEBA IHZvaWQga21lbV9yZWFwKHZvaWQpOwogaW50IGttZW1fZGVidWdnaW5nKHZvaWQpOwogdm9pZCAq Y2FsbG9jKHNpemVfdCBuLCBzaXplX3Qgcyk7CiAKKyNkZWZpbmUJZnJlZW1lbQkJCQkoY250LnZf ZnJlZV9jb3VudCArIGNudC52X2NhY2hlX2NvdW50KQorI2RlZmluZQltaW5mcmVlCQkJCWNudC52 X2ZyZWVfbWluCisjZGVmaW5lCWhlYXBfYXJlbmEJCQlrbWVtX2FyZW5hCiAjZGVmaW5lCWttZW1f YWxsb2Moc2l6ZSwga21mbGFncykJemZzX2ttZW1fYWxsb2MoKHNpemUpLCAoa21mbGFncykpCiAj ZGVmaW5lCWttZW1femFsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChzaXplKSwg KGttZmxhZ3MpIHwgTV9aRVJPKQogI2RlZmluZQlrbWVtX2ZyZWUoYnVmLCBzaXplKQkJemZzX2tt ZW1fZnJlZSgoYnVmKSwgKHNpemUpKQpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJp cy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmli L29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzExMTYpCisr KyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3 b3JraW5nIGNvcHkpCkBAIC0xOTMsOSArMTkzLDYgQEAgZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hf ZGlzYWJsZTsKICAqLwogc3RhdGljIGJvb2xlYW5fdCBhcmNfd2FybTsKIAotLyoKLSAqIFRoZXNl IHR1bmFibGVzIGFyZSBmb3IgcGVyZm9ybWFuY2UgYW5hbHlzaXMuCi0gKi8KIHVpbnQ2NF90IHpm c19hcmNfbWF4OwogdWludDY0X3QgemZzX2FyY19taW47CiB1aW50NjRfdCB6ZnNfYXJjX21ldGFf bGltaXQgPSAwOwpAQCAtMjA0LDcgKzIwMSwyMSBAQCBpbnQgemZzX2FyY19zaHJpbmtfc2hpZnQg PSAwOwogaW50IHpmc19hcmNfcF9taW5fc2hpZnQgPSAwOwogaW50IHpmc19kaXNhYmxlX2R1cF9l dmljdGlvbiA9IDA7CiB1aW50NjRfdCB6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEw MjQ7IC8qIDhLQiAqLwordV9pbnQgemZzX2FyY19mcmVlX3RhcmdldCA9ICgxIDw8IDE2KTsgLyog ZGVmYXVsdCBiZWZvcmUgcGFnZWRhZW1vbiBpbml0IG9ubHkgKi8KIAorc3RhdGljIGludCBzeXNj dGxfdmZzX3pmc19hcmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CisKKyNpZmRl ZiBfS0VSTkVMCitzdGF0aWMgdm9pZAorYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2Vk IF9fdW51c2VkKQoreworCisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2VvdXRfd2FrZXVw X3RocmVzaDsKK30KK1NZU0lOSVQoYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhSRUFE X1BBR0UsIFNJX09SREVSX0FOWSwKKyAgICBhcmNfZnJlZV90YXJnZXRfaW5pdCwgTlVMTCk7Cisj ZW5kaWYKKwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19tYXgiLCAmemZzX2FyY19tYXgpOwog VFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19taW4iLCAmemZzX2FyY19taW4pOwogVFVOQUJMRV9R VUFEKCJ2ZnMuemZzLmFyY19tZXRhX2xpbWl0IiwgJnpmc19hcmNfbWV0YV9saW1pdCk7CkBAIC0y MTcsNyArMjI4LDM2IEBAIFNZU0NUTF9VUVVBRChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19taW4s IENUTEZMQUdfCiBTWVNDVExfVVFVQUQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfYXZlcmFnZV9i bG9ja3NpemUsIENUTEZMQUdfUkRUVU4sCiAgICAgJnpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUs IDAsCiAgICAgIkFSQyBhdmVyYWdlIGJsb2Nrc2l6ZSIpOworLyoKKyAqIFdlIGRvbid0IGhhdmUg YSB0dW5hYmxlIGZvciBhcmNfZnJlZV90YXJnZXQgZHVlIHRvIHRoZSBkZXBlbmRlbmN5IG9uCisg KiBwYWdlZGFlbW9uIGluaXRpYWxpc2F0aW9uLgorICovCitTWVNDVExfUFJPQyhfdmZzX3pmcywg T0lEX0FVVE8sIGFyY19mcmVlX3RhcmdldCwKKyAgICBDVExUWVBFX1VJTlQgfCBDVExGTEFHX01Q U0FGRSB8IENUTEZMQUdfUlcsIDAsIHNpemVvZih1X2ludCksCisgICAgc3lzY3RsX3Zmc196ZnNf YXJjX2ZyZWVfdGFyZ2V0LCAiSVUiLAorICAgICJEZXNpcmVkIG51bWJlciBvZiBmcmVlIHBhZ2Vz IGJlbG93IHdoaWNoIEFSQyB0cmlnZ2VycyByZWNsYWltIik7CiAKK3N0YXRpYyBpbnQKK3N5c2N0 bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldChTWVNDVExfSEFORExFUl9BUkdTKQoreworCXVfaW50 IHZhbDsKKwlpbnQgZXJyOworCisJdmFsID0gemZzX2FyY19mcmVlX3RhcmdldDsKKwllcnIgPSBz eXNjdGxfaGFuZGxlX2ludChvaWRwLCAmdmFsLCAwLCByZXEpOworCWlmIChlcnIgIT0gMCB8fCBy ZXEtPm5ld3B0ciA9PSBOVUxMKQorCQlyZXR1cm4gKGVycik7CisKKwlpZiAodmFsIDwgbWluZnJl ZSkKKwkJcmV0dXJuIChFSU5WQUwpOworCWlmICh2YWwgPiBjbnQudl9wYWdlX2NvdW50KQorCQly ZXR1cm4gKEVJTlZBTCk7CisKKwl6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gdmFsOworCisJcmV0dXJu ICgwKTsKK30KKwogLyoKICAqIE5vdGUgdGhhdCBidWZmZXJzIGNhbiBiZSBpbiBvbmUgb2YgNiBz dGF0ZXM6CiAgKglBUkNfYW5vbgktIGFub255bW91cyAoZGlzY3Vzc2VkIGJlbG93KQpAQCAtMjQy MSw5ICsyNDYxLDEyIEBAIGFyY19mbHVzaChzcGFfdCAqc3BhKQogdm9pZAogYXJjX3Nocmluayh2 b2lkKQogeworCiAJaWYgKGFyY19jID4gYXJjX2NfbWluKSB7CiAJCXVpbnQ2NF90IHRvX2ZyZWU7 CiAKKwkJRFRSQUNFX1BST0JFMihhcmNfX3NocmluaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRf dCwKKwkJCWFyY19jX21pbik7CiAjaWZkZWYgX0tFUk5FTAogCQl0b19mcmVlID0gYXJjX2MgPj4g YXJjX3Nocmlua19zaGlmdDsKICNlbHNlCkBAIC0yNDQzLDggKzI0ODYsMTEgQEAgYXJjX3Nocmlu ayh2b2lkKQogCQlBU1NFUlQoKGludDY0X3QpYXJjX3AgPj0gMCk7CiAJfQogCi0JaWYgKGFyY19z aXplID4gYXJjX2MpCisJaWYgKGFyY19zaXplID4gYXJjX2MpIHsKKwkJRFRSQUNFX1BST0JFMihh cmNfX3Nocmlua19hZGp1c3QsIHVpbnQ2NF90LCBhcmNfc2l6ZSwKKwkJCXVpbnQ2NF90LCBhcmNf Yyk7CiAJCWFyY19hZGp1c3QoKTsKKwl9CiB9CiAKIHN0YXRpYyBpbnQgbmVlZGZyZWUgPSAwOwpA QCAtMjQ1NSwxNSArMjUwMSwyMCBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIAogI2lmZGVm IF9LRVJORUwKIAotCWlmIChuZWVkZnJlZSkKKwlpZiAobmVlZGZyZWUpIHsKKwkJRFRSQUNFX1BS T0JFKGFyY19fcmVjbGFpbV9uZWVkZnJlZSk7CiAJCXJldHVybiAoMSk7CisJfQogCiAJLyoKIAkg KiBDb29wZXJhdGUgd2l0aCBwYWdlZGFlbW9uIHdoZW4gaXQncyB0aW1lIGZvciBpdCB0byBzY2Fu CiAJICogYW5kIHJlY2xhaW0gc29tZSBwYWdlcy4KIAkgKi8KLQlpZiAodm1fcGFnaW5nX25lZWRl ZCgpKQorCWlmIChmcmVlbWVtIDwgemZzX2FyY19mcmVlX3RhcmdldCkgeworCQlEVFJBQ0VfUFJP QkUyKGFyY19fcmVjbGFpbV9mcmVlbWVtLCB1aW50NjRfdCwKKwkJICAgIGZyZWVtZW0sIHVpbnQ2 NF90LCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KTsKIAkJcmV0dXJuICgxKTsKKwl9CiAKICNpZmRlZiBz dW4KIAkvKgpAQCAtMjQ5MSw4ICsyNTQyLDE5IEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQog CWlmIChhdmFpbHJtZW0gPCBzd2FwZnNfbWluZnJlZSArIHN3YXBmc19yZXNlcnZlICsgZXh0cmEp CiAJCXJldHVybiAoMSk7CiAKLSNpZiBkZWZpbmVkKF9faTM4NikKIAkvKgorCSAqIENoZWNrIHRo YXQgd2UgaGF2ZSBlbm91Z2ggYXZhaWxybWVtIHRoYXQgbWVtb3J5IGxvY2tpbmcgKGUuZy4sIHZp YQorCSAqIG1sb2NrKDNDKSBvciBtZW1jbnRsKDIpKSBjYW4gc3RpbGwgc3VjY2VlZC4gIChwYWdl c19wcF9tYXhpbXVtCisJICogc3RvcmVzIHRoZSBudW1iZXIgb2YgcGFnZXMgdGhhdCBjYW5ub3Qg YmUgbG9ja2VkOyB3aGVuIGF2YWlscm1lbQorCSAqIGRyb3BzIGJlbG93IHBhZ2VzX3BwX21heGlt dW0sIHBhZ2UgbG9ja2luZyBtZWNoYW5pc21zIHN1Y2ggYXMKKwkgKiBwYWdlX3BwX2xvY2soKSB3 aWxsIGZhaWwuKQorCSAqLworCWlmIChhdmFpbHJtZW0gPD0gcGFnZXNfcHBfbWF4aW11bSkKKwkJ cmV0dXJuICgxKTsKKworI2VuZGlmCS8qIHN1biAqLworI2lmIGRlZmluZWQoX19pMzg2KSB8fCAh ZGVmaW5lZChVTUFfTURfU01BTExfQUxMT0MpCisJLyoKIAkgKiBJZiB3ZSdyZSBvbiBhbiBpMzg2 IHBsYXRmb3JtLCBpdCdzIHBvc3NpYmxlIHRoYXQgd2UnbGwgZXhoYXVzdCB0aGUKIAkgKiBrZXJu ZWwgaGVhcCBzcGFjZSBiZWZvcmUgd2UgZXZlciBydW4gb3V0IG9mIGF2YWlsYWJsZSBwaHlzaWNh bAogCSAqIG1lbW9yeS4gIE1vc3QgY2hlY2tzIG9mIHRoZSBzaXplIG9mIHRoZSBoZWFwX2FyZWEg Y29tcGFyZSBhZ2FpbnN0CkBAIC0yNTAzLDE5ICsyNTY1LDM1IEBAIGFyY19yZWNsYWltX25lZWRl ZCh2b2lkKQogCSAqIGhlYXAgaXMgYWxsb2NhdGVkLiAgKE9yLCBpbiB0aGUgY2FsY3VsYXRpb24s IGlmIGxlc3MgdGhhbiAxLzR0aCBpcwogCSAqIGZyZWUpCiAJICovCi0JaWYgKGJ0b3Aodm1lbV9z aXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkpIDwKLQkgICAgKGJ0b3Aodm1lbV9zaXplKGhlYXBf YXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+PiAyKSkKKwlpZiAodm1lbV9zaXplKGhl YXBfYXJlbmEsIFZNRU1fRlJFRSkgPAorCSAgICAodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1f RlJFRSB8IFZNRU1fQUxMT0MpID4+IDIpKSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19yZWNsYWlt X3VzZWQsIHVpbnQ2NF90LAorCQkgICAgdm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSks IHVpbnQ2NF90LAorCQkgICAgKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUgfCBWTUVN X0FMTE9DKSkgPj4gMik7CiAJCXJldHVybiAoMSk7CisJfQogI2VuZGlmCi0jZWxzZQkvKiAhc3Vu ICovCi0JaWYgKGttZW1fdXNlZCgpID4gKGttZW1fc2l6ZSgpICogMykgLyA0KQorI2lmZGVmIHN1 bgorCS8qCisJICogSWYgemlvIGRhdGEgcGFnZXMgYXJlIGJlaW5nIGFsbG9jYXRlZCBvdXQgb2Yg YSBzZXBhcmF0ZSBoZWFwIHNlZ21lbnQsCisJICogdGhlbiBlbmZvcmNlIHRoYXQgdGhlIHNpemUg b2YgYXZhaWxhYmxlIHZtZW0gZm9yIHRoaXMgYXJlbmEgcmVtYWlucworCSAqIGFib3ZlIGFib3V0 IDEvMTZ0aCBmcmVlLgorCSAqCisJICogTm90ZTogVGhlIDEvMTZ0aCBhcmVuYSBmcmVlIHJlcXVp cmVtZW50IHdhcyBwdXQgaW4gcGxhY2UKKwkgKiB0byBhZ2dyZXNzaXZlbHkgZXZpY3QgbWVtb3J5 IGZyb20gdGhlIGFyYyBpbiBvcmRlciB0byBhdm9pZAorCSAqIG1lbW9yeSBmcmFnbWVudGF0aW9u IGlzc3Vlcy4KKwkgKi8KKwlpZiAoemlvX2FyZW5hICE9IE5VTEwgJiYKKwkgICAgdm1lbV9zaXpl KHppb19hcmVuYSwgVk1FTV9GUkVFKSA8CisJICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVN X0FMTE9DKSA+PiA0KSkKIAkJcmV0dXJuICgxKTsKICNlbmRpZgkvKiBzdW4gKi8KLQotI2Vsc2UK KyNlbHNlCS8qIF9LRVJORUwgKi8KIAlpZiAoc3BhX2dldF9yYW5kb20oMTAwKSA9PSAwKQogCQly ZXR1cm4gKDEpOwotI2VuZGlmCisjZW5kaWYJLyogX0tFUk5FTCAqLworCURUUkFDRV9QUk9CRShh cmNfX3JlY2xhaW1fbm8pOworCiAJcmV0dXJuICgwKTsKIH0KIApAQCAtMjU2NCw2ICsyNjQyLDE1 IEBAIGFyY19rbWVtX3JlYXBfbm93KGFyY19yZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJfQog CWttZW1fY2FjaGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKIAlrbWVtX2NhY2hlX3JlYXBfbm93KGhk cl9jYWNoZSk7CisKKyNpZmRlZiBzdW4KKwkvKgorCSAqIEFzayB0aGUgdm1lbSBhcmVhbmEgdG8g cmVjbGFpbSB1bnVzZWQgbWVtb3J5IGZyb20gaXRzCisJICogcXVhbnR1bSBjYWNoZXMuCisJICov CisJaWYgKHppb19hcmVuYSAhPSBOVUxMICYmIHN0cmF0ID09IEFSQ19SRUNMQUlNX0FHR1IpCisJ CXZtZW1fcWNhY2hlX3JlYXAoemlvX2FyZW5hKTsKKyNlbmRpZgogfQogCiBzdGF0aWMgdm9pZApA QCAtMjcxMywyMCArMjgwMCw2IEBAIGFyY19ldmljdF9uZWVkZWQoYXJjX2J1Zl9jb250ZW50c190 IHR5cGUpCiAJaWYgKHR5cGUgPT0gQVJDX0JVRkNfTUVUQURBVEEgJiYgYXJjX21ldGFfdXNlZCA+ PSBhcmNfbWV0YV9saW1pdCkKIAkJcmV0dXJuICgxKTsKIAotI2lmZGVmIHN1bgotI2lmZGVmIF9L RVJORUwKLQkvKgotCSAqIElmIHppbyBkYXRhIHBhZ2VzIGFyZSBiZWluZyBhbGxvY2F0ZWQgb3V0 IG9mIGEgc2VwYXJhdGUgaGVhcCBzZWdtZW50LAotCSAqIHRoZW4gZW5mb3JjZSB0aGF0IHRoZSBz aXplIG9mIGF2YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFyZWEgcmVtYWlucwotCSAqIGFib3ZlIGFi b3V0IDEvMzJuZCBmcmVlLgotCSAqLwotCWlmICh0eXBlID09IEFSQ19CVUZDX0RBVEEgJiYgemlv X2FyZW5hICE9IE5VTEwgJiYKLQkgICAgdm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9GUkVFKSA8 Ci0JICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0FMTE9DKSA+PiA1KSkKLQkJcmV0dXJu ICgxKTsKLSNlbmRpZgotI2VuZGlmCS8qIHN1biAqLwotCiAJaWYgKGFyY19yZWNsYWltX25lZWRl ZCgpKQogCQlyZXR1cm4gKDEpOwogCkBAIC0zODg1LDIwICszOTU4LDE2IEBAIHN0YXRpYyBpbnQK IGFyY19tZW1vcnlfdGhyb3R0bGUodWludDY0X3QgcmVzZXJ2ZSwgdWludDY0X3QgdHhnKQogewog I2lmZGVmIF9LRVJORUwKLQl1aW50NjRfdCBhdmFpbGFibGVfbWVtb3J5ID0KLQkgICAgcHRvYSgo dWludG1heF90KWNudC52X2ZyZWVfY291bnQgKyBjbnQudl9jYWNoZV9jb3VudCk7CisJdWludDY0 X3QgYXZhaWxhYmxlX21lbW9yeSA9IHB0b2IoZnJlZW1lbSk7CiAJc3RhdGljIHVpbnQ2NF90IHBh Z2VfbG9hZCA9IDA7CiAJc3RhdGljIHVpbnQ2NF90IGxhc3RfdHhnID0gMDsKIAotI2lmZGVmIHN1 bgotI2lmIGRlZmluZWQoX19pMzg2KQorI2lmIGRlZmluZWQoX19pMzg2KSB8fCAhZGVmaW5lZChV TUFfTURfU01BTExfQUxMT0MpCiAJYXZhaWxhYmxlX21lbW9yeSA9Ci0JICAgIE1JTihhdmFpbGFi bGVfbWVtb3J5LCB2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSk7CisJICAgIE1JTihh dmFpbGFibGVfbWVtb3J5LCBwdG9iKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpKSk7 CiAjZW5kaWYKLSNlbmRpZgkvKiBzdW4gKi8KIAotCWlmIChjbnQudl9mcmVlX2NvdW50ICsgY250 LnZfY2FjaGVfY291bnQgPgotCSAgICAodWludDY0X3QpcGh5c21lbSAqIGFyY19sb3RzZnJlZV9w ZXJjZW50IC8gMTAwKQorCWlmIChmcmVlbWVtID4gKHVpbnQ2NF90KXBoeXNtZW0gKiBhcmNfbG90 c2ZyZWVfcGVyY2VudCAvIDEwMCkKIAkJcmV0dXJuICgwKTsKIAogCWlmICh0eGcgPiBsYXN0X3R4 ZykgewpAQCAtMzkxMSw3ICszOTgwLDcgQEAgYXJjX21lbW9yeV90aHJvdHRsZSh1aW50NjRfdCBy ZXNlcnZlLCB1aW50NjRfdCB0eGcKIAkgKiBjb250aW51ZSB0byBsZXQgcGFnZSB3cml0ZXMgb2Nj dXIgYXMgcXVpY2tseSBhcyBwb3NzaWJsZS4KIAkgKi8KIAlpZiAoY3VycHJvYyA9PSBwYWdlcHJv YykgewotCQlpZiAocGFnZV9sb2FkID4gYXZhaWxhYmxlX21lbW9yeSAvIDQpCisJCWlmIChwYWdl X2xvYWQgPiBNQVgocHRvYihtaW5mcmVlKSwgYXZhaWxhYmxlX21lbW9yeSkgLyA0KQogCQkJcmV0 dXJuIChTRVRfRVJST1IoRVJFU1RBUlQpKTsKIAkJLyogTm90ZTogcmVzZXJ2ZSBpcyBpbmZsYXRl ZCwgc28gd2UgZGVmbGF0ZSAqLwogCQlwYWdlX2xvYWQgKz0gcmVzZXJ2ZSAvIDg7Cg== 146817 2014-09-04 18:44:18 +0000 2014-09-05 09:15:57 +0000 arc reclam refactor (against head) arc-reclaim-head.patch text/plain 8890 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MDg3NSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTI2LDQyICsx MjYsNiBAQCBrbWVtX3NpemVfaW5pdCh2b2lkICp1bnVzZWQgX191bnVzZWQpCiB9CiBTWVNJTklU KGttZW1fc2l6ZV9pbml0LCBTSV9TVUJfS01FTSwgU0lfT1JERVJfQU5ZLCBrbWVtX3NpemVfaW5p dCwgTlVMTCk7CiAKLS8qCi0gKiBUaGUgcmV0dXJuIHZhbHVlcyBmcm9tIGttZW1fZnJlZV8qIGFy ZSBvbmx5IHZhbGlkIG9uY2UgdGhlIHBhZ2VkYWVtb24KLSAqIGhhcyBiZWVuIGluaXRpYWxpc2Vk LCBiZWZvcmUgdGhlbiB0aGV5IHJldHVybiAwLgotICogCi0gKiBUbyBlbnN1cmUgdGhlIHJldHVy bnMgYXJlIHZhbGlkIHRoZSBjYWxsZXIgY2FuIHVzZSBhIFNZU0lOSVQgd2l0aAotICogc3Vic3lz dGVtIHNldCB0byBTSV9TVUJfS1RIUkVBRF9QQUdFIGFuZCBhbiBvcmRlciBvZiBhdCBsZWFzdAot ICogU0lfT1JERVJfU0VDT05ELgotICovCi11X2ludAota21lbV9mcmVlX3RhcmdldCh2b2lkKQot ewotCi0JcmV0dXJuICh2bV9jbnQudl9mcmVlX3RhcmdldCk7Ci19Ci0KLXVfaW50Ci1rbWVtX2Zy ZWVfbWluKHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtX2NudC52X2ZyZWVfbWluKTsKLX0KLQotdV9p bnQKLWttZW1fZnJlZV9jb3VudCh2b2lkKQotewotCi0JcmV0dXJuICh2bV9jbnQudl9mcmVlX2Nv dW50ICsgdm1fY250LnZfY2FjaGVfY291bnQpOwotfQotCi11X2ludAota21lbV9wYWdlX2NvdW50 KHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtX2NudC52X3BhZ2VfY291bnQpOwotfQotCiB1aW50NjRf dAoga21lbV9zaXplKHZvaWQpCiB7CkBAIC0xNjksMTMgKzEzMyw2IEBAIGttZW1fc2l6ZSh2b2lk KQogCXJldHVybiAoa21lbV9zaXplX3ZhbCk7CiB9CiAKLXVpbnQ2NF90Ci1rbWVtX3VzZWQodm9p ZCkKLXsKLQotCXJldHVybiAodm1lbV9zaXplKGttZW1fYXJlbmEsIFZNRU1fQUxMT0MpKTsKLX0K LQogc3RhdGljIGludAoga21lbV9zdGRfY29uc3RydWN0b3Iodm9pZCAqbWVtLCBpbnQgc2l6ZSBf X3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgaW50IGZsYWdzKQogewpJbmRleDogc3lzL2NkZGwvY29t cGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29tcGF0 L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgJKHJldmlzaW9uIDI3MDg3NSkKKysrIHN5cy9jZGRsL2Nv bXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCSh3b3JraW5nIGNvcHkpCkBAIC02NiwxNyArNjYs NiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZvaWQgKnpmc19rbWVtX2FsbG9jKHNp emVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19rbWVtX2ZyZWUodm9pZCAqYnVmLCBz aXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9pZCk7Ci11aW50NjRfdCBrbWVtX3Vz ZWQodm9pZCk7Ci11X2ludCBrbWVtX3BhZ2VfY291bnQodm9pZCk7Ci0KLS8qCi0gKiBUaGUgcmV0 dXJuIHZhbHVlcyBmcm9tIGttZW1fZnJlZV8qIGFyZSBvbmx5IHZhbGlkIG9uY2UgdGhlIHBhZ2Vk YWVtb24KLSAqIGhhcyBiZWVuIGluaXRpYWxpc2VkLCBiZWZvcmUgdGhlbiB0aGV5IHJldHVybiAw LgotICovCi11X2ludCBrbWVtX2ZyZWVfY291bnQodm9pZCk7Ci11X2ludCBrbWVtX2ZyZWVfdGFy Z2V0KHZvaWQpOwotdV9pbnQga21lbV9mcmVlX21pbih2b2lkKTsKLQoga21lbV9jYWNoZV90ICpr bWVtX2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3QgYnVmc2l6ZSwgc2l6ZV90IGFsaWdu LAogICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZvaWQgKiwgaW50KSwgdm9pZCAoKmRl c3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lkICgqcmVjbGFpbSkodm9pZCAqKSBf X3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAsIGludCBjZmxhZ3MpOwpAQCAtODgs NiArNzcsOSBAQCB2b2lkIGttZW1fcmVhcCh2b2lkKTsKIGludCBrbWVtX2RlYnVnZ2luZyh2b2lk KTsKIHZvaWQgKmNhbGxvYyhzaXplX3Qgbiwgc2l6ZV90IHMpOwogCisjZGVmaW5lCWZyZWVtZW0J CQkJKHZtX2NudC52X2ZyZWVfY291bnQgKyB2bV9jbnQudl9jYWNoZV9jb3VudCkKKyNkZWZpbmUJ bWluZnJlZQkJCQl2bV9jbnQudl9mcmVlX21pbgorI2RlZmluZQloZWFwX2FyZW5hCQkJa21lbV9h cmVuYQogI2RlZmluZQlrbWVtX2FsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChz aXplKSwgKGttZmxhZ3MpKQogI2RlZmluZQlrbWVtX3phbGxvYyhzaXplLCBrbWZsYWdzKQl6ZnNf a21lbV9hbGxvYygoc2l6ZSksIChrbWZsYWdzKSB8IE1fWkVSTykKICNkZWZpbmUJa21lbV9mcmVl KGJ1Ziwgc2l6ZSkJCXpmc19rbWVtX2ZyZWUoKGJ1ZiksIChzaXplKSkKSW5kZXg6IHN5cy9jZGRs L2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvYXJjLmMKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwko cmV2aXNpb24gMjcwODc1KQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29t bW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMjAxLDcgKzIwMSw3IEBAIGludCB6 ZnNfYXJjX3Nocmlua19zaGlmdCA9IDA7CiBpbnQgemZzX2FyY19wX21pbl9zaGlmdCA9IDA7CiBp bnQgemZzX2Rpc2FibGVfZHVwX2V2aWN0aW9uID0gMDsKIHVpbnQ2NF90IHpmc19hcmNfYXZlcmFn ZV9ibG9ja3NpemUgPSA4ICogMTAyNDsgLyogOEtCICovCi11X2ludCB6ZnNfYXJjX2ZyZWVfdGFy Z2V0ID0gKDEgPDwgMTkpOyAvKiBkZWZhdWx0IGJlZm9yZSBwYWdlZGFlbW9uIGluaXQgb25seSAq LwordV9pbnQgemZzX2FyY19mcmVlX3RhcmdldCA9ICgxIDw8IDE2KTsgLyogZGVmYXVsdCBiZWZv cmUgcGFnZWRhZW1vbiBpbml0IG9ubHkgKi8KIAogc3RhdGljIGludCBzeXNjdGxfdmZzX3pmc19h cmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CiAKQEAgLTIxMCw3ICsyMTAsNyBA QCBzdGF0aWMgdm9pZAogYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2VkIF9fdW51c2Vk KQogewogCi0JemZzX2FyY19mcmVlX3RhcmdldCA9IGttZW1fZnJlZV90YXJnZXQoKTsKKwl6ZnNf YXJjX2ZyZWVfdGFyZ2V0ID0gdm1fcGFnZW91dF93YWtldXBfdGhyZXNoOwogfQogU1lTSU5JVChh cmNfZnJlZV90YXJnZXRfaW5pdCwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfQU5ZLAog ICAgIGFyY19mcmVlX3RhcmdldF9pbml0LCBOVUxMKTsKQEAgLTI0NSw5ICsyNDUsOSBAQCBzeXNj dGxfdmZzX3pmc19hcmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUwogCWlmIChlcnIg IT0gMCB8fCByZXEtPm5ld3B0ciA9PSBOVUxMKQogCQlyZXR1cm4gKGVycik7CiAKLQlpZiAodmFs IDwga21lbV9mcmVlX21pbigpKQorCWlmICh2YWwgPCBtaW5mcmVlKQogCQlyZXR1cm4gKEVJTlZB TCk7Ci0JaWYgKHZhbCA+IGttZW1fcGFnZV9jb3VudCgpKQorCWlmICh2YWwgPiB2bV9jbnQudl9w YWdlX2NvdW50KQogCQlyZXR1cm4gKEVJTlZBTCk7CiAKIAl6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0g dmFsOwpAQCAtMjUwMywxOCArMjUwMywxMyBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIAkJ cmV0dXJuICgxKTsKIAl9CiAKLQlpZiAoa21lbV9mcmVlX2NvdW50KCkgPCB6ZnNfYXJjX2ZyZWVf dGFyZ2V0KSB7Ci0JCURUUkFDRV9QUk9CRTIoYXJjX19yZWNsYWltX2ZyZWV0YXJnZXQsIHVpbnQ2 NF90LAotCQkgICAga21lbV9mcmVlX2NvdW50KCksIHVpbnQ2NF90LCB6ZnNfYXJjX2ZyZWVfdGFy Z2V0KTsKLQkJcmV0dXJuICgxKTsKLQl9Ci0KIAkvKgogCSAqIENvb3BlcmF0ZSB3aXRoIHBhZ2Vk YWVtb24gd2hlbiBpdCdzIHRpbWUgZm9yIGl0IHRvIHNjYW4KIAkgKiBhbmQgcmVjbGFpbSBzb21l IHBhZ2VzLgogCSAqLwotCWlmICh2bV9wYWdpbmdfbmVlZGVkKCkpIHsKLQkJRFRSQUNFX1BST0JF KGFyY19fcmVjbGFpbV9wYWdpbmcpOworCWlmIChmcmVlbWVtIDwgemZzX2FyY19mcmVlX3Rhcmdl dCkgeworCQlEVFJBQ0VfUFJPQkUyKGFyY19fcmVjbGFpbV9mcmVlbWVtLCB1aW50NjRfdCwKKwkJ ICAgIGZyZWVtZW0sIHVpbnQ2NF90LCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KTsKIAkJcmV0dXJuICgx KTsKIAl9CiAKQEAgLTI1NDQsOCArMjUzOSwxOSBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkK IAlpZiAoYXZhaWxybWVtIDwgc3dhcGZzX21pbmZyZWUgKyBzd2FwZnNfcmVzZXJ2ZSArIGV4dHJh KQogCQlyZXR1cm4gKDEpOwogCi0jaWYgZGVmaW5lZChfX2kzODYpCiAJLyoKKwkgKiBDaGVjayB0 aGF0IHdlIGhhdmUgZW5vdWdoIGF2YWlscm1lbSB0aGF0IG1lbW9yeSBsb2NraW5nIChlLmcuLCB2 aWEKKwkgKiBtbG9jaygzQykgb3IgbWVtY250bCgyKSkgY2FuIHN0aWxsIHN1Y2NlZWQuICAocGFn ZXNfcHBfbWF4aW11bQorCSAqIHN0b3JlcyB0aGUgbnVtYmVyIG9mIHBhZ2VzIHRoYXQgY2Fubm90 IGJlIGxvY2tlZDsgd2hlbiBhdmFpbHJtZW0KKwkgKiBkcm9wcyBiZWxvdyBwYWdlc19wcF9tYXhp bXVtLCBwYWdlIGxvY2tpbmcgbWVjaGFuaXNtcyBzdWNoIGFzCisJICogcGFnZV9wcF9sb2NrKCkg d2lsbCBmYWlsLikKKwkgKi8KKwlpZiAoYXZhaWxybWVtIDw9IHBhZ2VzX3BwX21heGltdW0pCisJ CXJldHVybiAoMSk7CisKKyNlbmRpZgkvKiBzdW4gKi8KKyNpZiBkZWZpbmVkKF9faTM4NikgfHwg IWRlZmluZWQoVU1BX01EX1NNQUxMX0FMTE9DKQorCS8qCiAJICogSWYgd2UncmUgb24gYW4gaTM4 NiBwbGF0Zm9ybSwgaXQncyBwb3NzaWJsZSB0aGF0IHdlJ2xsIGV4aGF1c3QgdGhlCiAJICoga2Vy bmVsIGhlYXAgc3BhY2UgYmVmb3JlIHdlIGV2ZXIgcnVuIG91dCBvZiBhdmFpbGFibGUgcGh5c2lj YWwKIAkgKiBtZW1vcnkuICBNb3N0IGNoZWNrcyBvZiB0aGUgc2l6ZSBvZiB0aGUgaGVhcF9hcmVh IGNvbXBhcmUgYWdhaW5zdApAQCAtMjU1NiwyNSArMjU2MiwzMyBAQCBhcmNfcmVjbGFpbV9uZWVk ZWQodm9pZCkKIAkgKiBoZWFwIGlzIGFsbG9jYXRlZC4gIChPciwgaW4gdGhlIGNhbGN1bGF0aW9u LCBpZiBsZXNzIHRoYW4gMS80dGggaXMKIAkgKiBmcmVlKQogCSAqLwotCWlmIChidG9wKHZtZW1f c2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpKSA8Ci0JICAgIChidG9wKHZtZW1fc2l6ZShoZWFw X2FyZW5hLCBWTUVNX0ZSRUUgfCBWTUVNX0FMTE9DKSkgPj4gMikpCi0JCXJldHVybiAoMSk7Ci0j ZW5kaWYKLSNlbHNlCS8qIHN1biAqLwotI2lmZGVmIF9faTM4Nl9fCi0JLyogaTM4NiBoYXMgS1ZB IGxpbWl0cyB0aGF0IHRoZSByYXcgcGFnZSBjb3VudHMgYWJvdmUgZG9uJ3QgY29uc2lkZXIgKi8K LQlpZiAoa21lbV91c2VkKCkgPiAoa21lbV9zaXplKCkgKiAzKSAvIDQpIHsKKwlpZiAodm1lbV9z aXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkgPAorCSAgICAodm1lbV9zaXplKGhlYXBfYXJlbmEs IFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpID4+IDIpKSB7CiAJCURUUkFDRV9QUk9CRTIoYXJjX19y ZWNsYWltX3VzZWQsIHVpbnQ2NF90LAotCQkgICAga21lbV91c2VkKCksIHVpbnQ2NF90LCAoa21l bV9zaXplKCkgKiAzKSAvIDQpOworCQkgICAgdm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJF RSksIHVpbnQ2NF90LAorCQkgICAgKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUgfCBW TUVNX0FMTE9DKSkgPj4gMik7CiAJCXJldHVybiAoMSk7CiAJfQogI2VuZGlmCisjaWZkZWYgc3Vu CisJLyoKKwkgKiBJZiB6aW8gZGF0YSBwYWdlcyBhcmUgYmVpbmcgYWxsb2NhdGVkIG91dCBvZiBh IHNlcGFyYXRlIGhlYXAgc2VnbWVudCwKKwkgKiB0aGVuIGVuZm9yY2UgdGhhdCB0aGUgc2l6ZSBv ZiBhdmFpbGFibGUgdm1lbSBmb3IgdGhpcyBhcmVuYSByZW1haW5zCisJICogYWJvdmUgYWJvdXQg MS8xNnRoIGZyZWUuCisJICoKKwkgKiBOb3RlOiBUaGUgMS8xNnRoIGFyZW5hIGZyZWUgcmVxdWly ZW1lbnQgd2FzIHB1dCBpbiBwbGFjZQorCSAqIHRvIGFnZ3Jlc3NpdmVseSBldmljdCBtZW1vcnkg ZnJvbSB0aGUgYXJjIGluIG9yZGVyIHRvIGF2b2lkCisJICogbWVtb3J5IGZyYWdtZW50YXRpb24g aXNzdWVzLgorCSAqLworCWlmICh6aW9fYXJlbmEgIT0gTlVMTCAmJgorCSAgICB2bWVtX3NpemUo emlvX2FyZW5hLCBWTUVNX0ZSRUUpIDwKKwkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1f QUxMT0MpID4+IDQpKQorCQlyZXR1cm4gKDEpOwogI2VuZGlmCS8qIHN1biAqLwotCi0jZWxzZQor I2Vsc2UJLyogX0tFUk5FTCAqLwogCWlmIChzcGFfZ2V0X3JhbmRvbSgxMDApID09IDApCiAJCXJl dHVybiAoMSk7Ci0jZW5kaWYKKyNlbmRpZgkvKiBfS0VSTkVMICovCiAJRFRSQUNFX1BST0JFKGFy Y19fcmVjbGFpbV9ubyk7CiAKIAlyZXR1cm4gKDApOwpAQCAtMjYyNSw2ICsyNjM5LDE1IEBAIGFy Y19rbWVtX3JlYXBfbm93KGFyY19yZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJfQogCWttZW1f Y2FjaGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKIAlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9jYWNo ZSk7CisKKyNpZmRlZiBzdW4KKwkvKgorCSAqIEFzayB0aGUgdm1lbSBhcmVhbmEgdG8gcmVjbGFp bSB1bnVzZWQgbWVtb3J5IGZyb20gaXRzCisJICogcXVhbnR1bSBjYWNoZXMuCisJICovCisJaWYg KHppb19hcmVuYSAhPSBOVUxMICYmIHN0cmF0ID09IEFSQ19SRUNMQUlNX0FHR1IpCisJCXZtZW1f cWNhY2hlX3JlYXAoemlvX2FyZW5hKTsKKyNlbmRpZgogfQogCiBzdGF0aWMgdm9pZApAQCAtMjc3 NCwyMCArMjc5Nyw2IEBAIGFyY19ldmljdF9uZWVkZWQoYXJjX2J1Zl9jb250ZW50c190IHR5cGUp CiAJaWYgKHR5cGUgPT0gQVJDX0JVRkNfTUVUQURBVEEgJiYgYXJjX21ldGFfdXNlZCA+PSBhcmNf bWV0YV9saW1pdCkKIAkJcmV0dXJuICgxKTsKIAotI2lmZGVmIHN1bgotI2lmZGVmIF9LRVJORUwK LQkvKgotCSAqIElmIHppbyBkYXRhIHBhZ2VzIGFyZSBiZWluZyBhbGxvY2F0ZWQgb3V0IG9mIGEg c2VwYXJhdGUgaGVhcCBzZWdtZW50LAotCSAqIHRoZW4gZW5mb3JjZSB0aGF0IHRoZSBzaXplIG9m IGF2YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFyZWEgcmVtYWlucwotCSAqIGFib3ZlIGFib3V0IDEv MzJuZCBmcmVlLgotCSAqLwotCWlmICh0eXBlID09IEFSQ19CVUZDX0RBVEEgJiYgemlvX2FyZW5h ICE9IE5VTEwgJiYKLQkgICAgdm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9GUkVFKSA8Ci0JICAg ICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0FMTE9DKSA+PiA1KSkKLQkJcmV0dXJuICgxKTsK LSNlbmRpZgotI2VuZGlmCS8qIHN1biAqLwotCiAJaWYgKGFyY19yZWNsYWltX25lZWRlZCgpKQog CQlyZXR1cm4gKDEpOwogCkBAIC0zOTQ2LDIwICszOTU1LDE2IEBAIHN0YXRpYyBpbnQKIGFyY19t ZW1vcnlfdGhyb3R0bGUodWludDY0X3QgcmVzZXJ2ZSwgdWludDY0X3QgdHhnKQogewogI2lmZGVm IF9LRVJORUwKLQl1aW50NjRfdCBhdmFpbGFibGVfbWVtb3J5ID0KLQkgICAgcHRvYSgodWludG1h eF90KXZtX2NudC52X2ZyZWVfY291bnQgKyB2bV9jbnQudl9jYWNoZV9jb3VudCk7CisJdWludDY0 X3QgYXZhaWxhYmxlX21lbW9yeSA9IHB0b2IoZnJlZW1lbSk7CiAJc3RhdGljIHVpbnQ2NF90IHBh Z2VfbG9hZCA9IDA7CiAJc3RhdGljIHVpbnQ2NF90IGxhc3RfdHhnID0gMDsKIAotI2lmZGVmIHN1 bgotI2lmIGRlZmluZWQoX19pMzg2KQorI2lmIGRlZmluZWQoX19pMzg2KSB8fCAhZGVmaW5lZChV TUFfTURfU01BTExfQUxMT0MpCiAJYXZhaWxhYmxlX21lbW9yeSA9Ci0JICAgIE1JTihhdmFpbGFi bGVfbWVtb3J5LCB2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSk7CisJICAgIE1JTihh dmFpbGFibGVfbWVtb3J5LCBwdG9iKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpKSk7 CiAjZW5kaWYKLSNlbmRpZgkvKiBzdW4gKi8KIAotCWlmICh2bV9jbnQudl9mcmVlX2NvdW50ICsg dm1fY250LnZfY2FjaGVfY291bnQgPgotCSAgICAodWludDY0X3QpcGh5c21lbSAqIGFyY19sb3Rz ZnJlZV9wZXJjZW50IC8gMTAwKQorCWlmIChmcmVlbWVtID4gKHVpbnQ2NF90KXBoeXNtZW0gKiBh cmNfbG90c2ZyZWVfcGVyY2VudCAvIDEwMCkKIAkJcmV0dXJuICgwKTsKIAogCWlmICh0eGcgPiBs YXN0X3R4ZykgewpAQCAtMzk3Miw3ICszOTc3LDcgQEAgYXJjX21lbW9yeV90aHJvdHRsZSh1aW50 NjRfdCByZXNlcnZlLCB1aW50NjRfdCB0eGcKIAkgKiBjb250aW51ZSB0byBsZXQgcGFnZSB3cml0 ZXMgb2NjdXIgYXMgcXVpY2tseSBhcyBwb3NzaWJsZS4KIAkgKi8KIAlpZiAoY3VycHJvYyA9PSBw YWdlcHJvYykgewotCQlpZiAocGFnZV9sb2FkID4gYXZhaWxhYmxlX21lbW9yeSAvIDQpCisJCWlm IChwYWdlX2xvYWQgPiBNQVgocHRvYihtaW5mcmVlKSwgYXZhaWxhYmxlX21lbW9yeSkgLyA0KQog CQkJcmV0dXJuIChTRVRfRVJST1IoRVJFU1RBUlQpKTsKIAkJLyogTm90ZTogcmVzZXJ2ZSBpcyBp bmZsYXRlZCwgc28gd2UgZGVmbGF0ZSAqLwogCQlwYWdlX2xvYWQgKz0gcmVzZXJ2ZSAvIDg7Cg== 146851 2014-09-05 09:15:24 +0000 2014-09-05 11:45:29 +0000 arc reclaim refactor (against stable/10) arc-reclaim-10.patch text/plain 9055 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MTExNikKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTMzLDEzICsx MzMsNiBAQCBrbWVtX3NpemUodm9pZCkKIAlyZXR1cm4gKGttZW1fc2l6ZV92YWwpOwogfQogCi11 aW50NjRfdAota21lbV91c2VkKHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtZW1fc2l6ZShrbWVtX2Fy ZW5hLCBWTUVNX0FMTE9DKSk7Ci19Ci0KIHN0YXRpYyBpbnQKIGttZW1fc3RkX2NvbnN0cnVjdG9y KHZvaWQgKm1lbSwgaW50IHNpemUgX191bnVzZWQsIHZvaWQgKnByaXZhdGUsIGludCBmbGFncykK IHsKSW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCShyZXZpc2lvbiAy NzExMTYpCisrKyBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMvc3lzL2ttZW0uaAkod29ya2lu ZyBjb3B5KQpAQCAtNjYsNyArNjYsNiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZv aWQgKnpmc19rbWVtX2FsbG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19r bWVtX2ZyZWUodm9pZCAqYnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9p ZCk7Ci11aW50NjRfdCBrbWVtX3VzZWQodm9pZCk7CiBrbWVtX2NhY2hlX3QgKmttZW1fY2FjaGVf Y3JlYXRlKGNoYXIgKm5hbWUsIHNpemVfdCBidWZzaXplLCBzaXplX3QgYWxpZ24sCiAgICAgaW50 ICgqY29uc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqLCBpbnQpLCB2b2lkICgqZGVzdHJ1Y3Rvciko dm9pZCAqLCB2b2lkICopLAogICAgIHZvaWQgKCpyZWNsYWltKSh2b2lkICopIF9fdW51c2VkLCB2 b2lkICpwcml2YXRlLCB2bWVtX3QgKnZtcCwgaW50IGNmbGFncyk7CkBAIC03OCw2ICs3Nyw5IEBA IHZvaWQga21lbV9yZWFwKHZvaWQpOwogaW50IGttZW1fZGVidWdnaW5nKHZvaWQpOwogdm9pZCAq Y2FsbG9jKHNpemVfdCBuLCBzaXplX3Qgcyk7CiAKKyNkZWZpbmUJZnJlZW1lbQkJCQkoY250LnZf ZnJlZV9jb3VudCArIGNudC52X2NhY2hlX2NvdW50KQorI2RlZmluZQltaW5mcmVlCQkJCWNudC52 X2ZyZWVfbWluCisjZGVmaW5lCWhlYXBfYXJlbmEJCQlrbWVtX2FyZW5hCiAjZGVmaW5lCWttZW1f YWxsb2Moc2l6ZSwga21mbGFncykJemZzX2ttZW1fYWxsb2MoKHNpemUpLCAoa21mbGFncykpCiAj ZGVmaW5lCWttZW1femFsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChzaXplKSwg KGttZmxhZ3MpIHwgTV9aRVJPKQogI2RlZmluZQlrbWVtX2ZyZWUoYnVmLCBzaXplKQkJemZzX2tt ZW1fZnJlZSgoYnVmKSwgKHNpemUpKQpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJp cy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmli L29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzExMTYpCisr KyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3 b3JraW5nIGNvcHkpCkBAIC0xOTMsOSArMTkzLDYgQEAgZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hf ZGlzYWJsZTsKICAqLwogc3RhdGljIGJvb2xlYW5fdCBhcmNfd2FybTsKIAotLyoKLSAqIFRoZXNl IHR1bmFibGVzIGFyZSBmb3IgcGVyZm9ybWFuY2UgYW5hbHlzaXMuCi0gKi8KIHVpbnQ2NF90IHpm c19hcmNfbWF4OwogdWludDY0X3QgemZzX2FyY19taW47CiB1aW50NjRfdCB6ZnNfYXJjX21ldGFf bGltaXQgPSAwOwpAQCAtMjA0LDcgKzIwMSwyMCBAQCBpbnQgemZzX2FyY19zaHJpbmtfc2hpZnQg PSAwOwogaW50IHpmc19hcmNfcF9taW5fc2hpZnQgPSAwOwogaW50IHpmc19kaXNhYmxlX2R1cF9l dmljdGlvbiA9IDA7CiB1aW50NjRfdCB6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEw MjQ7IC8qIDhLQiAqLwordV9pbnQgemZzX2FyY19mcmVlX3RhcmdldCA9ICgxIDw8IDE2KTsgLyog ZGVmYXVsdCBiZWZvcmUgcGFnZWRhZW1vbiBpbml0IG9ubHkgKi8KIAorc3RhdGljIGludCBzeXNj dGxfdmZzX3pmc19hcmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CisKKyNpZmRl ZiBfS0VSTkVMCitzdGF0aWMgdm9pZAorYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2Vk IF9fdW51c2VkKQoreworCisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2VvdXRfd2FrZXVw X3RocmVzaDsKK30KK1NZU0lOSVQoYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhSRUFE X1BBR0UsIFNJX09SREVSX0FOWSwKKyAgICBhcmNfZnJlZV90YXJnZXRfaW5pdCwgTlVMTCk7CisK IFRVTkFCTEVfUVVBRCgidmZzLnpmcy5hcmNfbWF4IiwgJnpmc19hcmNfbWF4KTsKIFRVTkFCTEVf UVVBRCgidmZzLnpmcy5hcmNfbWluIiwgJnpmc19hcmNfbWluKTsKIFRVTkFCTEVfUVVBRCgidmZz Lnpmcy5hcmNfbWV0YV9saW1pdCIsICZ6ZnNfYXJjX21ldGFfbGltaXQpOwpAQCAtMjE3LDcgKzIy NywzNyBAQCBTWVNDVExfVVFVQUQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfbWluLCBDVExGTEFH XwogU1lTQ1RMX1VRVUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2F2ZXJhZ2VfYmxvY2tzaXpl LCBDVExGTEFHX1JEVFVOLAogICAgICZ6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCAwLAogICAg ICJBUkMgYXZlcmFnZSBibG9ja3NpemUiKTsKKy8qCisgKiBXZSBkb24ndCBoYXZlIGEgdHVuYWJs ZSBmb3IgYXJjX2ZyZWVfdGFyZ2V0IGR1ZSB0byB0aGUgZGVwZW5kZW5jeSBvbgorICogcGFnZWRh ZW1vbiBpbml0aWFsaXNhdGlvbi4KKyAqLworU1lTQ1RMX1BST0MoX3Zmc196ZnMsIE9JRF9BVVRP LCBhcmNfZnJlZV90YXJnZXQsCisgICAgQ1RMVFlQRV9VSU5UIHwgQ1RMRkxBR19NUFNBRkUgfCBD VExGTEFHX1JXLCAwLCBzaXplb2YodV9pbnQpLAorICAgIHN5c2N0bF92ZnNfemZzX2FyY19mcmVl X3RhcmdldCwgIklVIiwKKyAgICAiRGVzaXJlZCBudW1iZXIgb2YgZnJlZSBwYWdlcyBiZWxvdyB3 aGljaCBBUkMgdHJpZ2dlcnMgcmVjbGFpbSIpOwogCitzdGF0aWMgaW50CitzeXNjdGxfdmZzX3pm c19hcmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUykKK3sKKwl1X2ludCB2YWw7CisJ aW50IGVycjsKKworCXZhbCA9IHpmc19hcmNfZnJlZV90YXJnZXQ7CisJZXJyID0gc3lzY3RsX2hh bmRsZV9pbnQob2lkcCwgJnZhbCwgMCwgcmVxKTsKKwlpZiAoZXJyICE9IDAgfHwgcmVxLT5uZXdw dHIgPT0gTlVMTCkKKwkJcmV0dXJuIChlcnIpOworCisJaWYgKHZhbCA8IG1pbmZyZWUpCisJCXJl dHVybiAoRUlOVkFMKTsKKwlpZiAodmFsID4gY250LnZfcGFnZV9jb3VudCkKKwkJcmV0dXJuIChF SU5WQUwpOworCisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZhbDsKKworCXJldHVybiAoMCk7Cit9 CisjZW5kaWYKKwogLyoKICAqIE5vdGUgdGhhdCBidWZmZXJzIGNhbiBiZSBpbiBvbmUgb2YgNiBz dGF0ZXM6CiAgKglBUkNfYW5vbgktIGFub255bW91cyAoZGlzY3Vzc2VkIGJlbG93KQpAQCAtMjQy MSw5ICsyNDYxLDEyIEBAIGFyY19mbHVzaChzcGFfdCAqc3BhKQogdm9pZAogYXJjX3Nocmluayh2 b2lkKQogeworCiAJaWYgKGFyY19jID4gYXJjX2NfbWluKSB7CiAJCXVpbnQ2NF90IHRvX2ZyZWU7 CiAKKwkJRFRSQUNFX1BST0JFMihhcmNfX3NocmluaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRf dCwKKwkJCWFyY19jX21pbik7CiAjaWZkZWYgX0tFUk5FTAogCQl0b19mcmVlID0gYXJjX2MgPj4g YXJjX3Nocmlua19zaGlmdDsKICNlbHNlCkBAIC0yNDQzLDggKzI0ODYsMTEgQEAgYXJjX3Nocmlu ayh2b2lkKQogCQlBU1NFUlQoKGludDY0X3QpYXJjX3AgPj0gMCk7CiAJfQogCi0JaWYgKGFyY19z aXplID4gYXJjX2MpCisJaWYgKGFyY19zaXplID4gYXJjX2MpIHsKKwkJRFRSQUNFX1BST0JFMihh cmNfX3Nocmlua19hZGp1c3QsIHVpbnQ2NF90LCBhcmNfc2l6ZSwKKwkJCXVpbnQ2NF90LCBhcmNf Yyk7CiAJCWFyY19hZGp1c3QoKTsKKwl9CiB9CiAKIHN0YXRpYyBpbnQgbmVlZGZyZWUgPSAwOwpA QCAtMjQ1NSwxNSArMjUwMSwyMCBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIAogI2lmZGVm IF9LRVJORUwKIAotCWlmIChuZWVkZnJlZSkKKwlpZiAobmVlZGZyZWUpIHsKKwkJRFRSQUNFX1BS T0JFKGFyY19fcmVjbGFpbV9uZWVkZnJlZSk7CiAJCXJldHVybiAoMSk7CisJfQogCiAJLyoKIAkg KiBDb29wZXJhdGUgd2l0aCBwYWdlZGFlbW9uIHdoZW4gaXQncyB0aW1lIGZvciBpdCB0byBzY2Fu CiAJICogYW5kIHJlY2xhaW0gc29tZSBwYWdlcy4KIAkgKi8KLQlpZiAodm1fcGFnaW5nX25lZWRl ZCgpKQorCWlmIChmcmVlbWVtIDwgemZzX2FyY19mcmVlX3RhcmdldCkgeworCQlEVFJBQ0VfUFJP QkUyKGFyY19fcmVjbGFpbV9mcmVlbWVtLCB1aW50NjRfdCwKKwkJICAgIGZyZWVtZW0sIHVpbnQ2 NF90LCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KTsKIAkJcmV0dXJuICgxKTsKKwl9CiAKICNpZmRlZiBz dW4KIAkvKgpAQCAtMjQ5MSw4ICsyNTQyLDE5IEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQog CWlmIChhdmFpbHJtZW0gPCBzd2FwZnNfbWluZnJlZSArIHN3YXBmc19yZXNlcnZlICsgZXh0cmEp CiAJCXJldHVybiAoMSk7CiAKLSNpZiBkZWZpbmVkKF9faTM4NikKIAkvKgorCSAqIENoZWNrIHRo YXQgd2UgaGF2ZSBlbm91Z2ggYXZhaWxybWVtIHRoYXQgbWVtb3J5IGxvY2tpbmcgKGUuZy4sIHZp YQorCSAqIG1sb2NrKDNDKSBvciBtZW1jbnRsKDIpKSBjYW4gc3RpbGwgc3VjY2VlZC4gIChwYWdl c19wcF9tYXhpbXVtCisJICogc3RvcmVzIHRoZSBudW1iZXIgb2YgcGFnZXMgdGhhdCBjYW5ub3Qg YmUgbG9ja2VkOyB3aGVuIGF2YWlscm1lbQorCSAqIGRyb3BzIGJlbG93IHBhZ2VzX3BwX21heGlt dW0sIHBhZ2UgbG9ja2luZyBtZWNoYW5pc21zIHN1Y2ggYXMKKwkgKiBwYWdlX3BwX2xvY2soKSB3 aWxsIGZhaWwuKQorCSAqLworCWlmIChhdmFpbHJtZW0gPD0gcGFnZXNfcHBfbWF4aW11bSkKKwkJ cmV0dXJuICgxKTsKKworI2VuZGlmCS8qIHN1biAqLworI2lmIGRlZmluZWQoX19pMzg2KSB8fCAh ZGVmaW5lZChVTUFfTURfU01BTExfQUxMT0MpCisJLyoKIAkgKiBJZiB3ZSdyZSBvbiBhbiBpMzg2 IHBsYXRmb3JtLCBpdCdzIHBvc3NpYmxlIHRoYXQgd2UnbGwgZXhoYXVzdCB0aGUKIAkgKiBrZXJu ZWwgaGVhcCBzcGFjZSBiZWZvcmUgd2UgZXZlciBydW4gb3V0IG9mIGF2YWlsYWJsZSBwaHlzaWNh bAogCSAqIG1lbW9yeS4gIE1vc3QgY2hlY2tzIG9mIHRoZSBzaXplIG9mIHRoZSBoZWFwX2FyZWEg Y29tcGFyZSBhZ2FpbnN0CkBAIC0yNTAzLDE5ICsyNTY1LDM1IEBAIGFyY19yZWNsYWltX25lZWRl ZCh2b2lkKQogCSAqIGhlYXAgaXMgYWxsb2NhdGVkLiAgKE9yLCBpbiB0aGUgY2FsY3VsYXRpb24s IGlmIGxlc3MgdGhhbiAxLzR0aCBpcwogCSAqIGZyZWUpCiAJICovCi0JaWYgKGJ0b3Aodm1lbV9z aXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkpIDwKLQkgICAgKGJ0b3Aodm1lbV9zaXplKGhlYXBf YXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+PiAyKSkKKwlpZiAodm1lbV9zaXplKGhl YXBfYXJlbmEsIFZNRU1fRlJFRSkgPAorCSAgICAodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1f RlJFRSB8IFZNRU1fQUxMT0MpID4+IDIpKSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19yZWNsYWlt X3VzZWQsIHVpbnQ2NF90LAorCQkgICAgdm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSks IHVpbnQ2NF90LAorCQkgICAgKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUgfCBWTUVN X0FMTE9DKSkgPj4gMik7CiAJCXJldHVybiAoMSk7CisJfQogI2VuZGlmCi0jZWxzZQkvKiAhc3Vu ICovCi0JaWYgKGttZW1fdXNlZCgpID4gKGttZW1fc2l6ZSgpICogMykgLyA0KQorI2lmZGVmIHN1 bgorCS8qCisJICogSWYgemlvIGRhdGEgcGFnZXMgYXJlIGJlaW5nIGFsbG9jYXRlZCBvdXQgb2Yg YSBzZXBhcmF0ZSBoZWFwIHNlZ21lbnQsCisJICogdGhlbiBlbmZvcmNlIHRoYXQgdGhlIHNpemUg b2YgYXZhaWxhYmxlIHZtZW0gZm9yIHRoaXMgYXJlbmEgcmVtYWlucworCSAqIGFib3ZlIGFib3V0 IDEvMTZ0aCBmcmVlLgorCSAqCisJICogTm90ZTogVGhlIDEvMTZ0aCBhcmVuYSBmcmVlIHJlcXVp cmVtZW50IHdhcyBwdXQgaW4gcGxhY2UKKwkgKiB0byBhZ2dyZXNzaXZlbHkgZXZpY3QgbWVtb3J5 IGZyb20gdGhlIGFyYyBpbiBvcmRlciB0byBhdm9pZAorCSAqIG1lbW9yeSBmcmFnbWVudGF0aW9u IGlzc3Vlcy4KKwkgKi8KKwlpZiAoemlvX2FyZW5hICE9IE5VTEwgJiYKKwkgICAgdm1lbV9zaXpl KHppb19hcmVuYSwgVk1FTV9GUkVFKSA8CisJICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVN X0FMTE9DKSA+PiA0KSkKIAkJcmV0dXJuICgxKTsKICNlbmRpZgkvKiBzdW4gKi8KLQotI2Vsc2UK KyNlbHNlCS8qIF9LRVJORUwgKi8KIAlpZiAoc3BhX2dldF9yYW5kb20oMTAwKSA9PSAwKQogCQly ZXR1cm4gKDEpOwotI2VuZGlmCisjZW5kaWYJLyogX0tFUk5FTCAqLworCURUUkFDRV9QUk9CRShh cmNfX3JlY2xhaW1fbm8pOworCiAJcmV0dXJuICgwKTsKIH0KIApAQCAtMjU2NCw2ICsyNjQyLDE1 IEBAIGFyY19rbWVtX3JlYXBfbm93KGFyY19yZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJfQog CWttZW1fY2FjaGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKIAlrbWVtX2NhY2hlX3JlYXBfbm93KGhk cl9jYWNoZSk7CisKKyNpZmRlZiBzdW4KKwkvKgorCSAqIEFzayB0aGUgdm1lbSBhcmVhbmEgdG8g cmVjbGFpbSB1bnVzZWQgbWVtb3J5IGZyb20gaXRzCisJICogcXVhbnR1bSBjYWNoZXMuCisJICov CisJaWYgKHppb19hcmVuYSAhPSBOVUxMICYmIHN0cmF0ID09IEFSQ19SRUNMQUlNX0FHR1IpCisJ CXZtZW1fcWNhY2hlX3JlYXAoemlvX2FyZW5hKTsKKyNlbmRpZgogfQogCiBzdGF0aWMgdm9pZApA QCAtMjcxMywyMCArMjgwMCw2IEBAIGFyY19ldmljdF9uZWVkZWQoYXJjX2J1Zl9jb250ZW50c190 IHR5cGUpCiAJaWYgKHR5cGUgPT0gQVJDX0JVRkNfTUVUQURBVEEgJiYgYXJjX21ldGFfdXNlZCA+ PSBhcmNfbWV0YV9saW1pdCkKIAkJcmV0dXJuICgxKTsKIAotI2lmZGVmIHN1bgotI2lmZGVmIF9L RVJORUwKLQkvKgotCSAqIElmIHppbyBkYXRhIHBhZ2VzIGFyZSBiZWluZyBhbGxvY2F0ZWQgb3V0 IG9mIGEgc2VwYXJhdGUgaGVhcCBzZWdtZW50LAotCSAqIHRoZW4gZW5mb3JjZSB0aGF0IHRoZSBz aXplIG9mIGF2YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFyZWEgcmVtYWlucwotCSAqIGFib3ZlIGFi b3V0IDEvMzJuZCBmcmVlLgotCSAqLwotCWlmICh0eXBlID09IEFSQ19CVUZDX0RBVEEgJiYgemlv X2FyZW5hICE9IE5VTEwgJiYKLQkgICAgdm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9GUkVFKSA8 Ci0JICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0FMTE9DKSA+PiA1KSkKLQkJcmV0dXJu ICgxKTsKLSNlbmRpZgotI2VuZGlmCS8qIHN1biAqLwotCiAJaWYgKGFyY19yZWNsYWltX25lZWRl ZCgpKQogCQlyZXR1cm4gKDEpOwogCkBAIC0zODg1LDIwICszOTU4LDE2IEBAIHN0YXRpYyBpbnQK IGFyY19tZW1vcnlfdGhyb3R0bGUodWludDY0X3QgcmVzZXJ2ZSwgdWludDY0X3QgdHhnKQogewog I2lmZGVmIF9LRVJORUwKLQl1aW50NjRfdCBhdmFpbGFibGVfbWVtb3J5ID0KLQkgICAgcHRvYSgo dWludG1heF90KWNudC52X2ZyZWVfY291bnQgKyBjbnQudl9jYWNoZV9jb3VudCk7CisJdWludDY0 X3QgYXZhaWxhYmxlX21lbW9yeSA9IHB0b2IoZnJlZW1lbSk7CiAJc3RhdGljIHVpbnQ2NF90IHBh Z2VfbG9hZCA9IDA7CiAJc3RhdGljIHVpbnQ2NF90IGxhc3RfdHhnID0gMDsKIAotI2lmZGVmIHN1 bgotI2lmIGRlZmluZWQoX19pMzg2KQorI2lmIGRlZmluZWQoX19pMzg2KSB8fCAhZGVmaW5lZChV TUFfTURfU01BTExfQUxMT0MpCiAJYXZhaWxhYmxlX21lbW9yeSA9Ci0JICAgIE1JTihhdmFpbGFi bGVfbWVtb3J5LCB2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSk7CisJICAgIE1JTihh dmFpbGFibGVfbWVtb3J5LCBwdG9iKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpKSk7 CiAjZW5kaWYKLSNlbmRpZgkvKiBzdW4gKi8KIAotCWlmIChjbnQudl9mcmVlX2NvdW50ICsgY250 LnZfY2FjaGVfY291bnQgPgotCSAgICAodWludDY0X3QpcGh5c21lbSAqIGFyY19sb3RzZnJlZV9w ZXJjZW50IC8gMTAwKQorCWlmIChmcmVlbWVtID4gKHVpbnQ2NF90KXBoeXNtZW0gKiBhcmNfbG90 c2ZyZWVfcGVyY2VudCAvIDEwMCkKIAkJcmV0dXJuICgwKTsKIAogCWlmICh0eGcgPiBsYXN0X3R4 ZykgewpAQCAtMzkxMSw3ICszOTgwLDcgQEAgYXJjX21lbW9yeV90aHJvdHRsZSh1aW50NjRfdCBy ZXNlcnZlLCB1aW50NjRfdCB0eGcKIAkgKiBjb250aW51ZSB0byBsZXQgcGFnZSB3cml0ZXMgb2Nj dXIgYXMgcXVpY2tseSBhcyBwb3NzaWJsZS4KIAkgKi8KIAlpZiAoY3VycHJvYyA9PSBwYWdlcHJv YykgewotCQlpZiAocGFnZV9sb2FkID4gYXZhaWxhYmxlX21lbW9yeSAvIDQpCisJCWlmIChwYWdl X2xvYWQgPiBNQVgocHRvYihtaW5mcmVlKSwgYXZhaWxhYmxlX21lbW9yeSkgLyA0KQogCQkJcmV0 dXJuIChTRVRfRVJST1IoRVJFU1RBUlQpKTsKIAkJLyogTm90ZTogcmVzZXJ2ZSBpcyBpbmZsYXRl ZCwgc28gd2UgZGVmbGF0ZSAqLwogCQlwYWdlX2xvYWQgKz0gcmVzZXJ2ZSAvIDg7Cg== 146852 2014-09-05 09:15:57 +0000 2014-09-05 11:46:32 +0000 arc reclam refactor (against head) arc-reclaim-head.patch text/plain 9141 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MDg3NSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTI2LDQyICsx MjYsNiBAQCBrbWVtX3NpemVfaW5pdCh2b2lkICp1bnVzZWQgX191bnVzZWQpCiB9CiBTWVNJTklU KGttZW1fc2l6ZV9pbml0LCBTSV9TVUJfS01FTSwgU0lfT1JERVJfQU5ZLCBrbWVtX3NpemVfaW5p dCwgTlVMTCk7CiAKLS8qCi0gKiBUaGUgcmV0dXJuIHZhbHVlcyBmcm9tIGttZW1fZnJlZV8qIGFy ZSBvbmx5IHZhbGlkIG9uY2UgdGhlIHBhZ2VkYWVtb24KLSAqIGhhcyBiZWVuIGluaXRpYWxpc2Vk LCBiZWZvcmUgdGhlbiB0aGV5IHJldHVybiAwLgotICogCi0gKiBUbyBlbnN1cmUgdGhlIHJldHVy bnMgYXJlIHZhbGlkIHRoZSBjYWxsZXIgY2FuIHVzZSBhIFNZU0lOSVQgd2l0aAotICogc3Vic3lz dGVtIHNldCB0byBTSV9TVUJfS1RIUkVBRF9QQUdFIGFuZCBhbiBvcmRlciBvZiBhdCBsZWFzdAot ICogU0lfT1JERVJfU0VDT05ELgotICovCi11X2ludAota21lbV9mcmVlX3RhcmdldCh2b2lkKQot ewotCi0JcmV0dXJuICh2bV9jbnQudl9mcmVlX3RhcmdldCk7Ci19Ci0KLXVfaW50Ci1rbWVtX2Zy ZWVfbWluKHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtX2NudC52X2ZyZWVfbWluKTsKLX0KLQotdV9p bnQKLWttZW1fZnJlZV9jb3VudCh2b2lkKQotewotCi0JcmV0dXJuICh2bV9jbnQudl9mcmVlX2Nv dW50ICsgdm1fY250LnZfY2FjaGVfY291bnQpOwotfQotCi11X2ludAota21lbV9wYWdlX2NvdW50 KHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtX2NudC52X3BhZ2VfY291bnQpOwotfQotCiB1aW50NjRf dAoga21lbV9zaXplKHZvaWQpCiB7CkBAIC0xNjksMTMgKzEzMyw2IEBAIGttZW1fc2l6ZSh2b2lk KQogCXJldHVybiAoa21lbV9zaXplX3ZhbCk7CiB9CiAKLXVpbnQ2NF90Ci1rbWVtX3VzZWQodm9p ZCkKLXsKLQotCXJldHVybiAodm1lbV9zaXplKGttZW1fYXJlbmEsIFZNRU1fQUxMT0MpKTsKLX0K LQogc3RhdGljIGludAoga21lbV9zdGRfY29uc3RydWN0b3Iodm9pZCAqbWVtLCBpbnQgc2l6ZSBf X3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgaW50IGZsYWdzKQogewpJbmRleDogc3lzL2NkZGwvY29t cGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29tcGF0 L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgJKHJldmlzaW9uIDI3MDg3NSkKKysrIHN5cy9jZGRsL2Nv bXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCSh3b3JraW5nIGNvcHkpCkBAIC02NiwxNyArNjYs NiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZvaWQgKnpmc19rbWVtX2FsbG9jKHNp emVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19rbWVtX2ZyZWUodm9pZCAqYnVmLCBz aXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9pZCk7Ci11aW50NjRfdCBrbWVtX3Vz ZWQodm9pZCk7Ci11X2ludCBrbWVtX3BhZ2VfY291bnQodm9pZCk7Ci0KLS8qCi0gKiBUaGUgcmV0 dXJuIHZhbHVlcyBmcm9tIGttZW1fZnJlZV8qIGFyZSBvbmx5IHZhbGlkIG9uY2UgdGhlIHBhZ2Vk YWVtb24KLSAqIGhhcyBiZWVuIGluaXRpYWxpc2VkLCBiZWZvcmUgdGhlbiB0aGV5IHJldHVybiAw LgotICovCi11X2ludCBrbWVtX2ZyZWVfY291bnQodm9pZCk7Ci11X2ludCBrbWVtX2ZyZWVfdGFy Z2V0KHZvaWQpOwotdV9pbnQga21lbV9mcmVlX21pbih2b2lkKTsKLQoga21lbV9jYWNoZV90ICpr bWVtX2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3QgYnVmc2l6ZSwgc2l6ZV90IGFsaWdu LAogICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZvaWQgKiwgaW50KSwgdm9pZCAoKmRl c3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lkICgqcmVjbGFpbSkodm9pZCAqKSBf X3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAsIGludCBjZmxhZ3MpOwpAQCAtODgs NiArNzcsOSBAQCB2b2lkIGttZW1fcmVhcCh2b2lkKTsKIGludCBrbWVtX2RlYnVnZ2luZyh2b2lk KTsKIHZvaWQgKmNhbGxvYyhzaXplX3Qgbiwgc2l6ZV90IHMpOwogCisjZGVmaW5lCWZyZWVtZW0J CQkJKHZtX2NudC52X2ZyZWVfY291bnQgKyB2bV9jbnQudl9jYWNoZV9jb3VudCkKKyNkZWZpbmUJ bWluZnJlZQkJCQl2bV9jbnQudl9mcmVlX21pbgorI2RlZmluZQloZWFwX2FyZW5hCQkJa21lbV9h cmVuYQogI2RlZmluZQlrbWVtX2FsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChz aXplKSwgKGttZmxhZ3MpKQogI2RlZmluZQlrbWVtX3phbGxvYyhzaXplLCBrbWZsYWdzKQl6ZnNf a21lbV9hbGxvYygoc2l6ZSksIChrbWZsYWdzKSB8IE1fWkVSTykKICNkZWZpbmUJa21lbV9mcmVl KGJ1Ziwgc2l6ZSkJCXpmc19rbWVtX2ZyZWUoKGJ1ZiksIChzaXplKSkKSW5kZXg6IHN5cy9jZGRs L2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvYXJjLmMKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwko cmV2aXNpb24gMjcwODc1KQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29t bW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMjAxLDcgKzIwMSw3IEBAIGludCB6 ZnNfYXJjX3Nocmlua19zaGlmdCA9IDA7CiBpbnQgemZzX2FyY19wX21pbl9zaGlmdCA9IDA7CiBp bnQgemZzX2Rpc2FibGVfZHVwX2V2aWN0aW9uID0gMDsKIHVpbnQ2NF90IHpmc19hcmNfYXZlcmFn ZV9ibG9ja3NpemUgPSA4ICogMTAyNDsgLyogOEtCICovCi11X2ludCB6ZnNfYXJjX2ZyZWVfdGFy Z2V0ID0gKDEgPDwgMTkpOyAvKiBkZWZhdWx0IGJlZm9yZSBwYWdlZGFlbW9uIGluaXQgb25seSAq LwordV9pbnQgemZzX2FyY19mcmVlX3RhcmdldCA9ICgxIDw8IDE2KTsgLyogZGVmYXVsdCBiZWZv cmUgcGFnZWRhZW1vbiBpbml0IG9ubHkgKi8KIAogc3RhdGljIGludCBzeXNjdGxfdmZzX3pmc19h cmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CiAKQEAgLTIxMCwxMSArMjEwLDEw IEBAIHN0YXRpYyB2b2lkCiBhcmNfZnJlZV90YXJnZXRfaW5pdCh2b2lkICp1bnVzZWQgX191bnVz ZWQpCiB7CiAKLQl6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0ga21lbV9mcmVlX3RhcmdldCgpOworCXpm c19hcmNfZnJlZV90YXJnZXQgPSB2bV9wYWdlb3V0X3dha2V1cF90aHJlc2g7CiB9CiBTWVNJTklU KGFyY19mcmVlX3RhcmdldF9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9BTlks CiAgICAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIE5VTEwpOwotI2VuZGlmCiAKIFRVTkFCTEVfUVVB RCgidmZzLnpmcy5hcmNfbWV0YV9saW1pdCIsICZ6ZnNfYXJjX21ldGFfbGltaXQpOwogU1lTQ1RM X0RFQ0woX3Zmc196ZnMpOwpAQCAtMjQ1LDkgKzI0NCw5IEBAIHN5c2N0bF92ZnNfemZzX2FyY19m cmVlX3RhcmdldChTWVNDVExfSEFORExFUl9BUkdTCiAJaWYgKGVyciAhPSAwIHx8IHJlcS0+bmV3 cHRyID09IE5VTEwpCiAJCXJldHVybiAoZXJyKTsKIAotCWlmICh2YWwgPCBrbWVtX2ZyZWVfbWlu KCkpCisJaWYgKHZhbCA8IG1pbmZyZWUpCiAJCXJldHVybiAoRUlOVkFMKTsKLQlpZiAodmFsID4g a21lbV9wYWdlX2NvdW50KCkpCisJaWYgKHZhbCA+IHZtX2NudC52X3BhZ2VfY291bnQpCiAJCXJl dHVybiAoRUlOVkFMKTsKIAogCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2YWw7CkBAIC0yNTQsNiAr MjUzLDcgQEAgc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0KFNZU0NUTF9IQU5ETEVSX0FS R1MKIAogCXJldHVybiAoMCk7CiB9CisjZW5kaWYKIAogLyoKICAqIE5vdGUgdGhhdCBidWZmZXJz IGNhbiBiZSBpbiBvbmUgb2YgNiBzdGF0ZXM6CkBAIC0yNTAzLDE4ICsyNTAzLDEzIEBAIGFyY19y ZWNsYWltX25lZWRlZCh2b2lkKQogCQlyZXR1cm4gKDEpOwogCX0KIAotCWlmIChrbWVtX2ZyZWVf Y291bnQoKSA8IHpmc19hcmNfZnJlZV90YXJnZXQpIHsKLQkJRFRSQUNFX1BST0JFMihhcmNfX3Jl Y2xhaW1fZnJlZXRhcmdldCwgdWludDY0X3QsCi0JCSAgICBrbWVtX2ZyZWVfY291bnQoKSwgdWlu dDY0X3QsIHpmc19hcmNfZnJlZV90YXJnZXQpOwotCQlyZXR1cm4gKDEpOwotCX0KLQogCS8qCiAJ ICogQ29vcGVyYXRlIHdpdGggcGFnZWRhZW1vbiB3aGVuIGl0J3MgdGltZSBmb3IgaXQgdG8gc2Nh bgogCSAqIGFuZCByZWNsYWltIHNvbWUgcGFnZXMuCiAJICovCi0JaWYgKHZtX3BhZ2luZ19uZWVk ZWQoKSkgewotCQlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX3BhZ2luZyk7CisJaWYgKGZyZWVt ZW0gPCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19yZWNsYWlt X2ZyZWVtZW0sIHVpbnQ2NF90LAorCQkgICAgZnJlZW1lbSwgdWludDY0X3QsIHpmc19hcmNfZnJl ZV90YXJnZXQpOwogCQlyZXR1cm4gKDEpOwogCX0KIApAQCAtMjU0NCw4ICsyNTM5LDE5IEBAIGFy Y19yZWNsYWltX25lZWRlZCh2b2lkKQogCWlmIChhdmFpbHJtZW0gPCBzd2FwZnNfbWluZnJlZSAr IHN3YXBmc19yZXNlcnZlICsgZXh0cmEpCiAJCXJldHVybiAoMSk7CiAKLSNpZiBkZWZpbmVkKF9f aTM4NikKIAkvKgorCSAqIENoZWNrIHRoYXQgd2UgaGF2ZSBlbm91Z2ggYXZhaWxybWVtIHRoYXQg bWVtb3J5IGxvY2tpbmcgKGUuZy4sIHZpYQorCSAqIG1sb2NrKDNDKSBvciBtZW1jbnRsKDIpKSBj YW4gc3RpbGwgc3VjY2VlZC4gIChwYWdlc19wcF9tYXhpbXVtCisJICogc3RvcmVzIHRoZSBudW1i ZXIgb2YgcGFnZXMgdGhhdCBjYW5ub3QgYmUgbG9ja2VkOyB3aGVuIGF2YWlscm1lbQorCSAqIGRy b3BzIGJlbG93IHBhZ2VzX3BwX21heGltdW0sIHBhZ2UgbG9ja2luZyBtZWNoYW5pc21zIHN1Y2gg YXMKKwkgKiBwYWdlX3BwX2xvY2soKSB3aWxsIGZhaWwuKQorCSAqLworCWlmIChhdmFpbHJtZW0g PD0gcGFnZXNfcHBfbWF4aW11bSkKKwkJcmV0dXJuICgxKTsKKworI2VuZGlmCS8qIHN1biAqLwor I2lmIGRlZmluZWQoX19pMzg2KSB8fCAhZGVmaW5lZChVTUFfTURfU01BTExfQUxMT0MpCisJLyoK IAkgKiBJZiB3ZSdyZSBvbiBhbiBpMzg2IHBsYXRmb3JtLCBpdCdzIHBvc3NpYmxlIHRoYXQgd2Un bGwgZXhoYXVzdCB0aGUKIAkgKiBrZXJuZWwgaGVhcCBzcGFjZSBiZWZvcmUgd2UgZXZlciBydW4g b3V0IG9mIGF2YWlsYWJsZSBwaHlzaWNhbAogCSAqIG1lbW9yeS4gIE1vc3QgY2hlY2tzIG9mIHRo ZSBzaXplIG9mIHRoZSBoZWFwX2FyZWEgY29tcGFyZSBhZ2FpbnN0CkBAIC0yNTU2LDI1ICsyNTYy LDMzIEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogCSAqIGhlYXAgaXMgYWxsb2NhdGVkLiAg KE9yLCBpbiB0aGUgY2FsY3VsYXRpb24sIGlmIGxlc3MgdGhhbiAxLzR0aCBpcwogCSAqIGZyZWUp CiAJICovCi0JaWYgKGJ0b3Aodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkpIDwKLQkg ICAgKGJ0b3Aodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+ PiAyKSkKLQkJcmV0dXJuICgxKTsKLSNlbmRpZgotI2Vsc2UJLyogc3VuICovCi0jaWZkZWYgX19p Mzg2X18KLQkvKiBpMzg2IGhhcyBLVkEgbGltaXRzIHRoYXQgdGhlIHJhdyBwYWdlIGNvdW50cyBh Ym92ZSBkb24ndCBjb25zaWRlciAqLwotCWlmIChrbWVtX3VzZWQoKSA+IChrbWVtX3NpemUoKSAq IDMpIC8gNCkgeworCWlmICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSA8CisJICAg ICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwgVk1FTV9BTExPQykgPj4gMikpIHsK IAkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fdXNlZCwgdWludDY0X3QsCi0JCSAgICBrbWVt X3VzZWQoKSwgdWludDY0X3QsIChrbWVtX3NpemUoKSAqIDMpIC8gNCk7CisJCSAgICB2bWVtX3Np emUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSwgdWludDY0X3QsCisJCSAgICAodm1lbV9zaXplKGhl YXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+PiAyKTsKIAkJcmV0dXJuICgxKTsK IAl9CiAjZW5kaWYKKyNpZmRlZiBzdW4KKwkvKgorCSAqIElmIHppbyBkYXRhIHBhZ2VzIGFyZSBi ZWluZyBhbGxvY2F0ZWQgb3V0IG9mIGEgc2VwYXJhdGUgaGVhcCBzZWdtZW50LAorCSAqIHRoZW4g ZW5mb3JjZSB0aGF0IHRoZSBzaXplIG9mIGF2YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFyZW5hIHJl bWFpbnMKKwkgKiBhYm92ZSBhYm91dCAxLzE2dGggZnJlZS4KKwkgKgorCSAqIE5vdGU6IFRoZSAx LzE2dGggYXJlbmEgZnJlZSByZXF1aXJlbWVudCB3YXMgcHV0IGluIHBsYWNlCisJICogdG8gYWdn cmVzc2l2ZWx5IGV2aWN0IG1lbW9yeSBmcm9tIHRoZSBhcmMgaW4gb3JkZXIgdG8gYXZvaWQKKwkg KiBtZW1vcnkgZnJhZ21lbnRhdGlvbiBpc3N1ZXMuCisJICovCisJaWYgKHppb19hcmVuYSAhPSBO VUxMICYmCisJICAgIHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fRlJFRSkgPAorCSAgICAodm1l bV9zaXplKHppb19hcmVuYSwgVk1FTV9BTExPQykgPj4gNCkpCisJCXJldHVybiAoMSk7CiAjZW5k aWYJLyogc3VuICovCi0KLSNlbHNlCisjZWxzZQkvKiBfS0VSTkVMICovCiAJaWYgKHNwYV9nZXRf cmFuZG9tKDEwMCkgPT0gMCkKIAkJcmV0dXJuICgxKTsKLSNlbmRpZgorI2VuZGlmCS8qIF9LRVJO RUwgKi8KIAlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX25vKTsKIAogCXJldHVybiAoMCk7CkBA IC0yNjI1LDYgKzI2MzksMTUgQEAgYXJjX2ttZW1fcmVhcF9ub3coYXJjX3JlY2xhaW1fc3RyYXRl Z3lfdCBzdHJhdCkKIAl9CiAJa21lbV9jYWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOwogCWttZW1f Y2FjaGVfcmVhcF9ub3coaGRyX2NhY2hlKTsKKworI2lmZGVmIHN1bgorCS8qCisJICogQXNrIHRo ZSB2bWVtIGFyZWFuYSB0byByZWNsYWltIHVudXNlZCBtZW1vcnkgZnJvbSBpdHMKKwkgKiBxdWFu dHVtIGNhY2hlcy4KKwkgKi8KKwlpZiAoemlvX2FyZW5hICE9IE5VTEwgJiYgc3RyYXQgPT0gQVJD X1JFQ0xBSU1fQUdHUikKKwkJdm1lbV9xY2FjaGVfcmVhcCh6aW9fYXJlbmEpOworI2VuZGlmCiB9 CiAKIHN0YXRpYyB2b2lkCkBAIC0yNzc0LDIwICsyNzk3LDYgQEAgYXJjX2V2aWN0X25lZWRlZChh cmNfYnVmX2NvbnRlbnRzX3QgdHlwZSkKIAlpZiAodHlwZSA9PSBBUkNfQlVGQ19NRVRBREFUQSAm JiBhcmNfbWV0YV91c2VkID49IGFyY19tZXRhX2xpbWl0KQogCQlyZXR1cm4gKDEpOwogCi0jaWZk ZWYgc3VuCi0jaWZkZWYgX0tFUk5FTAotCS8qCi0JICogSWYgemlvIGRhdGEgcGFnZXMgYXJlIGJl aW5nIGFsbG9jYXRlZCBvdXQgb2YgYSBzZXBhcmF0ZSBoZWFwIHNlZ21lbnQsCi0JICogdGhlbiBl bmZvcmNlIHRoYXQgdGhlIHNpemUgb2YgYXZhaWxhYmxlIHZtZW0gZm9yIHRoaXMgYXJlYSByZW1h aW5zCi0JICogYWJvdmUgYWJvdXQgMS8zMm5kIGZyZWUuCi0JICovCi0JaWYgKHR5cGUgPT0gQVJD X0JVRkNfREFUQSAmJiB6aW9fYXJlbmEgIT0gTlVMTCAmJgotCSAgICB2bWVtX3NpemUoemlvX2Fy ZW5hLCBWTUVNX0ZSRUUpIDwKLQkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fQUxMT0Mp ID4+IDUpKQotCQlyZXR1cm4gKDEpOwotI2VuZGlmCi0jZW5kaWYJLyogc3VuICovCi0KIAlpZiAo YXJjX3JlY2xhaW1fbmVlZGVkKCkpCiAJCXJldHVybiAoMSk7CiAKQEAgLTM5NDYsMjAgKzM5NTUs MTYgQEAgc3RhdGljIGludAogYXJjX21lbW9yeV90aHJvdHRsZSh1aW50NjRfdCByZXNlcnZlLCB1 aW50NjRfdCB0eGcpCiB7CiAjaWZkZWYgX0tFUk5FTAotCXVpbnQ2NF90IGF2YWlsYWJsZV9tZW1v cnkgPQotCSAgICBwdG9hKCh1aW50bWF4X3Qpdm1fY250LnZfZnJlZV9jb3VudCArIHZtX2NudC52 X2NhY2hlX2NvdW50KTsKKwl1aW50NjRfdCBhdmFpbGFibGVfbWVtb3J5ID0gcHRvYihmcmVlbWVt KTsKIAlzdGF0aWMgdWludDY0X3QgcGFnZV9sb2FkID0gMDsKIAlzdGF0aWMgdWludDY0X3QgbGFz dF90eGcgPSAwOwogCi0jaWZkZWYgc3VuCi0jaWYgZGVmaW5lZChfX2kzODYpCisjaWYgZGVmaW5l ZChfX2kzODYpIHx8ICFkZWZpbmVkKFVNQV9NRF9TTUFMTF9BTExPQykKIAlhdmFpbGFibGVfbWVt b3J5ID0KLQkgICAgTUlOKGF2YWlsYWJsZV9tZW1vcnksIHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBW TUVNX0ZSRUUpKTsKKwkgICAgTUlOKGF2YWlsYWJsZV9tZW1vcnksIHB0b2Iodm1lbV9zaXplKGhl YXBfYXJlbmEsIFZNRU1fRlJFRSkpKTsKICNlbmRpZgotI2VuZGlmCS8qIHN1biAqLwogCi0JaWYg KHZtX2NudC52X2ZyZWVfY291bnQgKyB2bV9jbnQudl9jYWNoZV9jb3VudCA+Ci0JICAgICh1aW50 NjRfdClwaHlzbWVtICogYXJjX2xvdHNmcmVlX3BlcmNlbnQgLyAxMDApCisJaWYgKGZyZWVtZW0g PiAodWludDY0X3QpcGh5c21lbSAqIGFyY19sb3RzZnJlZV9wZXJjZW50IC8gMTAwKQogCQlyZXR1 cm4gKDApOwogCiAJaWYgKHR4ZyA+IGxhc3RfdHhnKSB7CkBAIC0zOTcyLDcgKzM5NzcsNyBAQCBh cmNfbWVtb3J5X3Rocm90dGxlKHVpbnQ2NF90IHJlc2VydmUsIHVpbnQ2NF90IHR4ZwogCSAqIGNv bnRpbnVlIHRvIGxldCBwYWdlIHdyaXRlcyBvY2N1ciBhcyBxdWlja2x5IGFzIHBvc3NpYmxlLgog CSAqLwogCWlmIChjdXJwcm9jID09IHBhZ2Vwcm9jKSB7Ci0JCWlmIChwYWdlX2xvYWQgPiBhdmFp bGFibGVfbWVtb3J5IC8gNCkKKwkJaWYgKHBhZ2VfbG9hZCA+IE1BWChwdG9iKG1pbmZyZWUpLCBh dmFpbGFibGVfbWVtb3J5KSAvIDQpCiAJCQlyZXR1cm4gKFNFVF9FUlJPUihFUkVTVEFSVCkpOwog CQkvKiBOb3RlOiByZXNlcnZlIGlzIGluZmxhdGVkLCBzbyB3ZSBkZWZsYXRlICovCiAJCXBhZ2Vf bG9hZCArPSByZXNlcnZlIC8gODsK 146854 2014-09-05 09:30:48 +0000 2014-09-05 11:45:29 +0000 arc reclaim refactor (against stable/10) arc-reclaim-10.patch text/plain 9055 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MTExNikKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTMzLDEzICsx MzMsNiBAQCBrbWVtX3NpemUodm9pZCkKIAlyZXR1cm4gKGttZW1fc2l6ZV92YWwpOwogfQogCi11 aW50NjRfdAota21lbV91c2VkKHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtZW1fc2l6ZShrbWVtX2Fy ZW5hLCBWTUVNX0FMTE9DKSk7Ci19Ci0KIHN0YXRpYyBpbnQKIGttZW1fc3RkX2NvbnN0cnVjdG9y KHZvaWQgKm1lbSwgaW50IHNpemUgX191bnVzZWQsIHZvaWQgKnByaXZhdGUsIGludCBmbGFncykK IHsKSW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCShyZXZpc2lvbiAy NzExMTYpCisrKyBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMvc3lzL2ttZW0uaAkod29ya2lu ZyBjb3B5KQpAQCAtNjYsNyArNjYsNiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZv aWQgKnpmc19rbWVtX2FsbG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19r bWVtX2ZyZWUodm9pZCAqYnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9p ZCk7Ci11aW50NjRfdCBrbWVtX3VzZWQodm9pZCk7CiBrbWVtX2NhY2hlX3QgKmttZW1fY2FjaGVf Y3JlYXRlKGNoYXIgKm5hbWUsIHNpemVfdCBidWZzaXplLCBzaXplX3QgYWxpZ24sCiAgICAgaW50 ICgqY29uc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqLCBpbnQpLCB2b2lkICgqZGVzdHJ1Y3Rvciko dm9pZCAqLCB2b2lkICopLAogICAgIHZvaWQgKCpyZWNsYWltKSh2b2lkICopIF9fdW51c2VkLCB2 b2lkICpwcml2YXRlLCB2bWVtX3QgKnZtcCwgaW50IGNmbGFncyk7CkBAIC03OCw2ICs3Nyw5IEBA IHZvaWQga21lbV9yZWFwKHZvaWQpOwogaW50IGttZW1fZGVidWdnaW5nKHZvaWQpOwogdm9pZCAq Y2FsbG9jKHNpemVfdCBuLCBzaXplX3Qgcyk7CiAKKyNkZWZpbmUJZnJlZW1lbQkJCQkoY250LnZf ZnJlZV9jb3VudCArIGNudC52X2NhY2hlX2NvdW50KQorI2RlZmluZQltaW5mcmVlCQkJCWNudC52 X2ZyZWVfbWluCisjZGVmaW5lCWhlYXBfYXJlbmEJCQlrbWVtX2FyZW5hCiAjZGVmaW5lCWttZW1f YWxsb2Moc2l6ZSwga21mbGFncykJemZzX2ttZW1fYWxsb2MoKHNpemUpLCAoa21mbGFncykpCiAj ZGVmaW5lCWttZW1femFsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChzaXplKSwg KGttZmxhZ3MpIHwgTV9aRVJPKQogI2RlZmluZQlrbWVtX2ZyZWUoYnVmLCBzaXplKQkJemZzX2tt ZW1fZnJlZSgoYnVmKSwgKHNpemUpKQpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJp cy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmli L29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzExMTYpCisr KyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3 b3JraW5nIGNvcHkpCkBAIC0xOTMsOSArMTkzLDYgQEAgZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hf ZGlzYWJsZTsKICAqLwogc3RhdGljIGJvb2xlYW5fdCBhcmNfd2FybTsKIAotLyoKLSAqIFRoZXNl IHR1bmFibGVzIGFyZSBmb3IgcGVyZm9ybWFuY2UgYW5hbHlzaXMuCi0gKi8KIHVpbnQ2NF90IHpm c19hcmNfbWF4OwogdWludDY0X3QgemZzX2FyY19taW47CiB1aW50NjRfdCB6ZnNfYXJjX21ldGFf bGltaXQgPSAwOwpAQCAtMjA0LDcgKzIwMSwyMCBAQCBpbnQgemZzX2FyY19zaHJpbmtfc2hpZnQg PSAwOwogaW50IHpmc19hcmNfcF9taW5fc2hpZnQgPSAwOwogaW50IHpmc19kaXNhYmxlX2R1cF9l dmljdGlvbiA9IDA7CiB1aW50NjRfdCB6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEw MjQ7IC8qIDhLQiAqLwordV9pbnQgemZzX2FyY19mcmVlX3RhcmdldCA9ICgxIDw8IDE2KTsgLyog ZGVmYXVsdCBiZWZvcmUgcGFnZWRhZW1vbiBpbml0IG9ubHkgKi8KIAorc3RhdGljIGludCBzeXNj dGxfdmZzX3pmc19hcmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CisKKyNpZmRl ZiBfS0VSTkVMCitzdGF0aWMgdm9pZAorYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2Vk IF9fdW51c2VkKQoreworCisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2VvdXRfd2FrZXVw X3RocmVzaDsKK30KK1NZU0lOSVQoYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhSRUFE X1BBR0UsIFNJX09SREVSX0FOWSwKKyAgICBhcmNfZnJlZV90YXJnZXRfaW5pdCwgTlVMTCk7CisK IFRVTkFCTEVfUVVBRCgidmZzLnpmcy5hcmNfbWF4IiwgJnpmc19hcmNfbWF4KTsKIFRVTkFCTEVf UVVBRCgidmZzLnpmcy5hcmNfbWluIiwgJnpmc19hcmNfbWluKTsKIFRVTkFCTEVfUVVBRCgidmZz Lnpmcy5hcmNfbWV0YV9saW1pdCIsICZ6ZnNfYXJjX21ldGFfbGltaXQpOwpAQCAtMjE3LDcgKzIy NywzNyBAQCBTWVNDVExfVVFVQUQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfbWluLCBDVExGTEFH XwogU1lTQ1RMX1VRVUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2F2ZXJhZ2VfYmxvY2tzaXpl LCBDVExGTEFHX1JEVFVOLAogICAgICZ6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCAwLAogICAg ICJBUkMgYXZlcmFnZSBibG9ja3NpemUiKTsKKy8qCisgKiBXZSBkb24ndCBoYXZlIGEgdHVuYWJs ZSBmb3IgYXJjX2ZyZWVfdGFyZ2V0IGR1ZSB0byB0aGUgZGVwZW5kZW5jeSBvbgorICogcGFnZWRh ZW1vbiBpbml0aWFsaXNhdGlvbi4KKyAqLworU1lTQ1RMX1BST0MoX3Zmc196ZnMsIE9JRF9BVVRP LCBhcmNfZnJlZV90YXJnZXQsCisgICAgQ1RMVFlQRV9VSU5UIHwgQ1RMRkxBR19NUFNBRkUgfCBD VExGTEFHX1JXLCAwLCBzaXplb2YodV9pbnQpLAorICAgIHN5c2N0bF92ZnNfemZzX2FyY19mcmVl X3RhcmdldCwgIklVIiwKKyAgICAiRGVzaXJlZCBudW1iZXIgb2YgZnJlZSBwYWdlcyBiZWxvdyB3 aGljaCBBUkMgdHJpZ2dlcnMgcmVjbGFpbSIpOwogCitzdGF0aWMgaW50CitzeXNjdGxfdmZzX3pm c19hcmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUykKK3sKKwl1X2ludCB2YWw7CisJ aW50IGVycjsKKworCXZhbCA9IHpmc19hcmNfZnJlZV90YXJnZXQ7CisJZXJyID0gc3lzY3RsX2hh bmRsZV9pbnQob2lkcCwgJnZhbCwgMCwgcmVxKTsKKwlpZiAoZXJyICE9IDAgfHwgcmVxLT5uZXdw dHIgPT0gTlVMTCkKKwkJcmV0dXJuIChlcnIpOworCisJaWYgKHZhbCA8IG1pbmZyZWUpCisJCXJl dHVybiAoRUlOVkFMKTsKKwlpZiAodmFsID4gY250LnZfcGFnZV9jb3VudCkKKwkJcmV0dXJuIChF SU5WQUwpOworCisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZhbDsKKworCXJldHVybiAoMCk7Cit9 CisjZW5kaWYKKwogLyoKICAqIE5vdGUgdGhhdCBidWZmZXJzIGNhbiBiZSBpbiBvbmUgb2YgNiBz dGF0ZXM6CiAgKglBUkNfYW5vbgktIGFub255bW91cyAoZGlzY3Vzc2VkIGJlbG93KQpAQCAtMjQy MSw5ICsyNDYxLDEyIEBAIGFyY19mbHVzaChzcGFfdCAqc3BhKQogdm9pZAogYXJjX3Nocmluayh2 b2lkKQogeworCiAJaWYgKGFyY19jID4gYXJjX2NfbWluKSB7CiAJCXVpbnQ2NF90IHRvX2ZyZWU7 CiAKKwkJRFRSQUNFX1BST0JFMihhcmNfX3NocmluaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRf dCwKKwkJCWFyY19jX21pbik7CiAjaWZkZWYgX0tFUk5FTAogCQl0b19mcmVlID0gYXJjX2MgPj4g YXJjX3Nocmlua19zaGlmdDsKICNlbHNlCkBAIC0yNDQzLDggKzI0ODYsMTEgQEAgYXJjX3Nocmlu ayh2b2lkKQogCQlBU1NFUlQoKGludDY0X3QpYXJjX3AgPj0gMCk7CiAJfQogCi0JaWYgKGFyY19z aXplID4gYXJjX2MpCisJaWYgKGFyY19zaXplID4gYXJjX2MpIHsKKwkJRFRSQUNFX1BST0JFMihh cmNfX3Nocmlua19hZGp1c3QsIHVpbnQ2NF90LCBhcmNfc2l6ZSwKKwkJCXVpbnQ2NF90LCBhcmNf Yyk7CiAJCWFyY19hZGp1c3QoKTsKKwl9CiB9CiAKIHN0YXRpYyBpbnQgbmVlZGZyZWUgPSAwOwpA QCAtMjQ1NSwxNSArMjUwMSwyMCBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIAogI2lmZGVm IF9LRVJORUwKIAotCWlmIChuZWVkZnJlZSkKKwlpZiAobmVlZGZyZWUpIHsKKwkJRFRSQUNFX1BS T0JFKGFyY19fcmVjbGFpbV9uZWVkZnJlZSk7CiAJCXJldHVybiAoMSk7CisJfQogCiAJLyoKIAkg KiBDb29wZXJhdGUgd2l0aCBwYWdlZGFlbW9uIHdoZW4gaXQncyB0aW1lIGZvciBpdCB0byBzY2Fu CiAJICogYW5kIHJlY2xhaW0gc29tZSBwYWdlcy4KIAkgKi8KLQlpZiAodm1fcGFnaW5nX25lZWRl ZCgpKQorCWlmIChmcmVlbWVtIDwgemZzX2FyY19mcmVlX3RhcmdldCkgeworCQlEVFJBQ0VfUFJP QkUyKGFyY19fcmVjbGFpbV9mcmVlbWVtLCB1aW50NjRfdCwKKwkJICAgIGZyZWVtZW0sIHVpbnQ2 NF90LCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KTsKIAkJcmV0dXJuICgxKTsKKwl9CiAKICNpZmRlZiBz dW4KIAkvKgpAQCAtMjQ5MSw4ICsyNTQyLDE5IEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQog CWlmIChhdmFpbHJtZW0gPCBzd2FwZnNfbWluZnJlZSArIHN3YXBmc19yZXNlcnZlICsgZXh0cmEp CiAJCXJldHVybiAoMSk7CiAKLSNpZiBkZWZpbmVkKF9faTM4NikKIAkvKgorCSAqIENoZWNrIHRo YXQgd2UgaGF2ZSBlbm91Z2ggYXZhaWxybWVtIHRoYXQgbWVtb3J5IGxvY2tpbmcgKGUuZy4sIHZp YQorCSAqIG1sb2NrKDNDKSBvciBtZW1jbnRsKDIpKSBjYW4gc3RpbGwgc3VjY2VlZC4gIChwYWdl c19wcF9tYXhpbXVtCisJICogc3RvcmVzIHRoZSBudW1iZXIgb2YgcGFnZXMgdGhhdCBjYW5ub3Qg YmUgbG9ja2VkOyB3aGVuIGF2YWlscm1lbQorCSAqIGRyb3BzIGJlbG93IHBhZ2VzX3BwX21heGlt dW0sIHBhZ2UgbG9ja2luZyBtZWNoYW5pc21zIHN1Y2ggYXMKKwkgKiBwYWdlX3BwX2xvY2soKSB3 aWxsIGZhaWwuKQorCSAqLworCWlmIChhdmFpbHJtZW0gPD0gcGFnZXNfcHBfbWF4aW11bSkKKwkJ cmV0dXJuICgxKTsKKworI2VuZGlmCS8qIHN1biAqLworI2lmIGRlZmluZWQoX19pMzg2KSB8fCAh ZGVmaW5lZChVTUFfTURfU01BTExfQUxMT0MpCisJLyoKIAkgKiBJZiB3ZSdyZSBvbiBhbiBpMzg2 IHBsYXRmb3JtLCBpdCdzIHBvc3NpYmxlIHRoYXQgd2UnbGwgZXhoYXVzdCB0aGUKIAkgKiBrZXJu ZWwgaGVhcCBzcGFjZSBiZWZvcmUgd2UgZXZlciBydW4gb3V0IG9mIGF2YWlsYWJsZSBwaHlzaWNh bAogCSAqIG1lbW9yeS4gIE1vc3QgY2hlY2tzIG9mIHRoZSBzaXplIG9mIHRoZSBoZWFwX2FyZWEg Y29tcGFyZSBhZ2FpbnN0CkBAIC0yNTAzLDE5ICsyNTY1LDM1IEBAIGFyY19yZWNsYWltX25lZWRl ZCh2b2lkKQogCSAqIGhlYXAgaXMgYWxsb2NhdGVkLiAgKE9yLCBpbiB0aGUgY2FsY3VsYXRpb24s IGlmIGxlc3MgdGhhbiAxLzR0aCBpcwogCSAqIGZyZWUpCiAJICovCi0JaWYgKGJ0b3Aodm1lbV9z aXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkpIDwKLQkgICAgKGJ0b3Aodm1lbV9zaXplKGhlYXBf YXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+PiAyKSkKKwlpZiAodm1lbV9zaXplKGhl YXBfYXJlbmEsIFZNRU1fRlJFRSkgPAorCSAgICAodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1f RlJFRSB8IFZNRU1fQUxMT0MpID4+IDIpKSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19yZWNsYWlt X3VzZWQsIHVpbnQ2NF90LAorCQkgICAgdm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSks IHVpbnQ2NF90LAorCQkgICAgKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUgfCBWTUVN X0FMTE9DKSkgPj4gMik7CiAJCXJldHVybiAoMSk7CisJfQogI2VuZGlmCi0jZWxzZQkvKiAhc3Vu ICovCi0JaWYgKGttZW1fdXNlZCgpID4gKGttZW1fc2l6ZSgpICogMykgLyA0KQorI2lmZGVmIHN1 bgorCS8qCisJICogSWYgemlvIGRhdGEgcGFnZXMgYXJlIGJlaW5nIGFsbG9jYXRlZCBvdXQgb2Yg YSBzZXBhcmF0ZSBoZWFwIHNlZ21lbnQsCisJICogdGhlbiBlbmZvcmNlIHRoYXQgdGhlIHNpemUg b2YgYXZhaWxhYmxlIHZtZW0gZm9yIHRoaXMgYXJlbmEgcmVtYWlucworCSAqIGFib3ZlIGFib3V0 IDEvMTZ0aCBmcmVlLgorCSAqCisJICogTm90ZTogVGhlIDEvMTZ0aCBhcmVuYSBmcmVlIHJlcXVp cmVtZW50IHdhcyBwdXQgaW4gcGxhY2UKKwkgKiB0byBhZ2dyZXNzaXZlbHkgZXZpY3QgbWVtb3J5 IGZyb20gdGhlIGFyYyBpbiBvcmRlciB0byBhdm9pZAorCSAqIG1lbW9yeSBmcmFnbWVudGF0aW9u IGlzc3Vlcy4KKwkgKi8KKwlpZiAoemlvX2FyZW5hICE9IE5VTEwgJiYKKwkgICAgdm1lbV9zaXpl KHppb19hcmVuYSwgVk1FTV9GUkVFKSA8CisJICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVN X0FMTE9DKSA+PiA0KSkKIAkJcmV0dXJuICgxKTsKICNlbmRpZgkvKiBzdW4gKi8KLQotI2Vsc2UK KyNlbHNlCS8qIF9LRVJORUwgKi8KIAlpZiAoc3BhX2dldF9yYW5kb20oMTAwKSA9PSAwKQogCQly ZXR1cm4gKDEpOwotI2VuZGlmCisjZW5kaWYJLyogX0tFUk5FTCAqLworCURUUkFDRV9QUk9CRShh cmNfX3JlY2xhaW1fbm8pOworCiAJcmV0dXJuICgwKTsKIH0KIApAQCAtMjU2NCw2ICsyNjQyLDE1 IEBAIGFyY19rbWVtX3JlYXBfbm93KGFyY19yZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJfQog CWttZW1fY2FjaGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKIAlrbWVtX2NhY2hlX3JlYXBfbm93KGhk cl9jYWNoZSk7CisKKyNpZmRlZiBzdW4KKwkvKgorCSAqIEFzayB0aGUgdm1lbSBhcmVhbmEgdG8g cmVjbGFpbSB1bnVzZWQgbWVtb3J5IGZyb20gaXRzCisJICogcXVhbnR1bSBjYWNoZXMuCisJICov CisJaWYgKHppb19hcmVuYSAhPSBOVUxMICYmIHN0cmF0ID09IEFSQ19SRUNMQUlNX0FHR1IpCisJ CXZtZW1fcWNhY2hlX3JlYXAoemlvX2FyZW5hKTsKKyNlbmRpZgogfQogCiBzdGF0aWMgdm9pZApA QCAtMjcxMywyMCArMjgwMCw2IEBAIGFyY19ldmljdF9uZWVkZWQoYXJjX2J1Zl9jb250ZW50c190 IHR5cGUpCiAJaWYgKHR5cGUgPT0gQVJDX0JVRkNfTUVUQURBVEEgJiYgYXJjX21ldGFfdXNlZCA+ PSBhcmNfbWV0YV9saW1pdCkKIAkJcmV0dXJuICgxKTsKIAotI2lmZGVmIHN1bgotI2lmZGVmIF9L RVJORUwKLQkvKgotCSAqIElmIHppbyBkYXRhIHBhZ2VzIGFyZSBiZWluZyBhbGxvY2F0ZWQgb3V0 IG9mIGEgc2VwYXJhdGUgaGVhcCBzZWdtZW50LAotCSAqIHRoZW4gZW5mb3JjZSB0aGF0IHRoZSBz aXplIG9mIGF2YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFyZWEgcmVtYWlucwotCSAqIGFib3ZlIGFi b3V0IDEvMzJuZCBmcmVlLgotCSAqLwotCWlmICh0eXBlID09IEFSQ19CVUZDX0RBVEEgJiYgemlv X2FyZW5hICE9IE5VTEwgJiYKLQkgICAgdm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9GUkVFKSA8 Ci0JICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0FMTE9DKSA+PiA1KSkKLQkJcmV0dXJu ICgxKTsKLSNlbmRpZgotI2VuZGlmCS8qIHN1biAqLwotCiAJaWYgKGFyY19yZWNsYWltX25lZWRl ZCgpKQogCQlyZXR1cm4gKDEpOwogCkBAIC0zODg1LDIwICszOTU4LDE2IEBAIHN0YXRpYyBpbnQK IGFyY19tZW1vcnlfdGhyb3R0bGUodWludDY0X3QgcmVzZXJ2ZSwgdWludDY0X3QgdHhnKQogewog I2lmZGVmIF9LRVJORUwKLQl1aW50NjRfdCBhdmFpbGFibGVfbWVtb3J5ID0KLQkgICAgcHRvYSgo dWludG1heF90KWNudC52X2ZyZWVfY291bnQgKyBjbnQudl9jYWNoZV9jb3VudCk7CisJdWludDY0 X3QgYXZhaWxhYmxlX21lbW9yeSA9IHB0b2IoZnJlZW1lbSk7CiAJc3RhdGljIHVpbnQ2NF90IHBh Z2VfbG9hZCA9IDA7CiAJc3RhdGljIHVpbnQ2NF90IGxhc3RfdHhnID0gMDsKIAotI2lmZGVmIHN1 bgotI2lmIGRlZmluZWQoX19pMzg2KQorI2lmIGRlZmluZWQoX19pMzg2KSB8fCAhZGVmaW5lZChV TUFfTURfU01BTExfQUxMT0MpCiAJYXZhaWxhYmxlX21lbW9yeSA9Ci0JICAgIE1JTihhdmFpbGFi bGVfbWVtb3J5LCB2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSk7CisJICAgIE1JTihh dmFpbGFibGVfbWVtb3J5LCBwdG9iKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpKSk7 CiAjZW5kaWYKLSNlbmRpZgkvKiBzdW4gKi8KIAotCWlmIChjbnQudl9mcmVlX2NvdW50ICsgY250 LnZfY2FjaGVfY291bnQgPgotCSAgICAodWludDY0X3QpcGh5c21lbSAqIGFyY19sb3RzZnJlZV9w ZXJjZW50IC8gMTAwKQorCWlmIChmcmVlbWVtID4gKHVpbnQ2NF90KXBoeXNtZW0gKiBhcmNfbG90 c2ZyZWVfcGVyY2VudCAvIDEwMCkKIAkJcmV0dXJuICgwKTsKIAogCWlmICh0eGcgPiBsYXN0X3R4 ZykgewpAQCAtMzkxMSw3ICszOTgwLDcgQEAgYXJjX21lbW9yeV90aHJvdHRsZSh1aW50NjRfdCBy ZXNlcnZlLCB1aW50NjRfdCB0eGcKIAkgKiBjb250aW51ZSB0byBsZXQgcGFnZSB3cml0ZXMgb2Nj dXIgYXMgcXVpY2tseSBhcyBwb3NzaWJsZS4KIAkgKi8KIAlpZiAoY3VycHJvYyA9PSBwYWdlcHJv YykgewotCQlpZiAocGFnZV9sb2FkID4gYXZhaWxhYmxlX21lbW9yeSAvIDQpCisJCWlmIChwYWdl X2xvYWQgPiBNQVgocHRvYihtaW5mcmVlKSwgYXZhaWxhYmxlX21lbW9yeSkgLyA0KQogCQkJcmV0 dXJuIChTRVRfRVJST1IoRVJFU1RBUlQpKTsKIAkJLyogTm90ZTogcmVzZXJ2ZSBpcyBpbmZsYXRl ZCwgc28gd2UgZGVmbGF0ZSAqLwogCQlwYWdlX2xvYWQgKz0gcmVzZXJ2ZSAvIDg7Cg== 146859 2014-09-05 11:45:29 +0000 2014-09-06 16:38:13 +0000 arc reclaim refactor (against stable/10) arc-reclaim-10.patch text/plain 10703 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MTExNikKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTMzLDEzICsx MzMsNiBAQCBrbWVtX3NpemUodm9pZCkKIAlyZXR1cm4gKGttZW1fc2l6ZV92YWwpOwogfQogCi11 aW50NjRfdAota21lbV91c2VkKHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtZW1fc2l6ZShrbWVtX2Fy ZW5hLCBWTUVNX0FMTE9DKSk7Ci19Ci0KIHN0YXRpYyBpbnQKIGttZW1fc3RkX2NvbnN0cnVjdG9y KHZvaWQgKm1lbSwgaW50IHNpemUgX191bnVzZWQsIHZvaWQgKnByaXZhdGUsIGludCBmbGFncykK IHsKSW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCShyZXZpc2lvbiAy NzExMTYpCisrKyBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMvc3lzL2ttZW0uaAkod29ya2lu ZyBjb3B5KQpAQCAtNjYsNyArNjYsNiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZv aWQgKnpmc19rbWVtX2FsbG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19r bWVtX2ZyZWUodm9pZCAqYnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9p ZCk7Ci11aW50NjRfdCBrbWVtX3VzZWQodm9pZCk7CiBrbWVtX2NhY2hlX3QgKmttZW1fY2FjaGVf Y3JlYXRlKGNoYXIgKm5hbWUsIHNpemVfdCBidWZzaXplLCBzaXplX3QgYWxpZ24sCiAgICAgaW50 ICgqY29uc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqLCBpbnQpLCB2b2lkICgqZGVzdHJ1Y3Rvciko dm9pZCAqLCB2b2lkICopLAogICAgIHZvaWQgKCpyZWNsYWltKSh2b2lkICopIF9fdW51c2VkLCB2 b2lkICpwcml2YXRlLCB2bWVtX3QgKnZtcCwgaW50IGNmbGFncyk7CkBAIC03OCw2ICs3Nyw5IEBA IHZvaWQga21lbV9yZWFwKHZvaWQpOwogaW50IGttZW1fZGVidWdnaW5nKHZvaWQpOwogdm9pZCAq Y2FsbG9jKHNpemVfdCBuLCBzaXplX3Qgcyk7CiAKKyNkZWZpbmUJZnJlZW1lbQkJCQkoY250LnZf ZnJlZV9jb3VudCArIGNudC52X2NhY2hlX2NvdW50KQorI2RlZmluZQltaW5mcmVlCQkJCWNudC52 X2ZyZWVfbWluCisjZGVmaW5lCWhlYXBfYXJlbmEJCQlrbWVtX2FyZW5hCiAjZGVmaW5lCWttZW1f YWxsb2Moc2l6ZSwga21mbGFncykJemZzX2ttZW1fYWxsb2MoKHNpemUpLCAoa21mbGFncykpCiAj ZGVmaW5lCWttZW1femFsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChzaXplKSwg KGttZmxhZ3MpIHwgTV9aRVJPKQogI2RlZmluZQlrbWVtX2ZyZWUoYnVmLCBzaXplKQkJemZzX2tt ZW1fZnJlZSgoYnVmKSwgKHNpemUpKQpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJp cy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmli L29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzExMTYpCisr KyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3 b3JraW5nIGNvcHkpCkBAIC0xOTMsOSArMTkzLDYgQEAgZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hf ZGlzYWJsZTsKICAqLwogc3RhdGljIGJvb2xlYW5fdCBhcmNfd2FybTsKIAotLyoKLSAqIFRoZXNl IHR1bmFibGVzIGFyZSBmb3IgcGVyZm9ybWFuY2UgYW5hbHlzaXMuCi0gKi8KIHVpbnQ2NF90IHpm c19hcmNfbWF4OwogdWludDY0X3QgemZzX2FyY19taW47CiB1aW50NjRfdCB6ZnNfYXJjX21ldGFf bGltaXQgPSAwOwpAQCAtMjA0LDcgKzIwMSwyMCBAQCBpbnQgemZzX2FyY19zaHJpbmtfc2hpZnQg PSAwOwogaW50IHpmc19hcmNfcF9taW5fc2hpZnQgPSAwOwogaW50IHpmc19kaXNhYmxlX2R1cF9l dmljdGlvbiA9IDA7CiB1aW50NjRfdCB6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEw MjQ7IC8qIDhLQiAqLwordV9pbnQgemZzX2FyY19mcmVlX3RhcmdldCA9ICgxIDw8IDE2KTsgLyog ZGVmYXVsdCBiZWZvcmUgcGFnZWRhZW1vbiBpbml0IG9ubHkgKi8KIAorc3RhdGljIGludCBzeXNj dGxfdmZzX3pmc19hcmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CisKKyNpZmRl ZiBfS0VSTkVMCitzdGF0aWMgdm9pZAorYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2Vk IF9fdW51c2VkKQoreworCisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2VvdXRfd2FrZXVw X3RocmVzaDsKK30KK1NZU0lOSVQoYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhSRUFE X1BBR0UsIFNJX09SREVSX0FOWSwKKyAgICBhcmNfZnJlZV90YXJnZXRfaW5pdCwgTlVMTCk7CisK IFRVTkFCTEVfUVVBRCgidmZzLnpmcy5hcmNfbWF4IiwgJnpmc19hcmNfbWF4KTsKIFRVTkFCTEVf UVVBRCgidmZzLnpmcy5hcmNfbWluIiwgJnpmc19hcmNfbWluKTsKIFRVTkFCTEVfUVVBRCgidmZz Lnpmcy5hcmNfbWV0YV9saW1pdCIsICZ6ZnNfYXJjX21ldGFfbGltaXQpOwpAQCAtMjE3LDcgKzIy NywzNyBAQCBTWVNDVExfVVFVQUQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfbWluLCBDVExGTEFH XwogU1lTQ1RMX1VRVUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2F2ZXJhZ2VfYmxvY2tzaXpl LCBDVExGTEFHX1JEVFVOLAogICAgICZ6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCAwLAogICAg ICJBUkMgYXZlcmFnZSBibG9ja3NpemUiKTsKKy8qCisgKiBXZSBkb24ndCBoYXZlIGEgdHVuYWJs ZSBmb3IgYXJjX2ZyZWVfdGFyZ2V0IGR1ZSB0byB0aGUgZGVwZW5kZW5jeSBvbgorICogcGFnZWRh ZW1vbiBpbml0aWFsaXNhdGlvbi4KKyAqLworU1lTQ1RMX1BST0MoX3Zmc196ZnMsIE9JRF9BVVRP LCBhcmNfZnJlZV90YXJnZXQsCisgICAgQ1RMVFlQRV9VSU5UIHwgQ1RMRkxBR19NUFNBRkUgfCBD VExGTEFHX1JXLCAwLCBzaXplb2YodV9pbnQpLAorICAgIHN5c2N0bF92ZnNfemZzX2FyY19mcmVl X3RhcmdldCwgIklVIiwKKyAgICAiRGVzaXJlZCBudW1iZXIgb2YgZnJlZSBwYWdlcyBiZWxvdyB3 aGljaCBBUkMgdHJpZ2dlcnMgcmVjbGFpbSIpOwogCitzdGF0aWMgaW50CitzeXNjdGxfdmZzX3pm c19hcmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUykKK3sKKwl1X2ludCB2YWw7CisJ aW50IGVycjsKKworCXZhbCA9IHpmc19hcmNfZnJlZV90YXJnZXQ7CisJZXJyID0gc3lzY3RsX2hh bmRsZV9pbnQob2lkcCwgJnZhbCwgMCwgcmVxKTsKKwlpZiAoZXJyICE9IDAgfHwgcmVxLT5uZXdw dHIgPT0gTlVMTCkKKwkJcmV0dXJuIChlcnIpOworCisJaWYgKHZhbCA8IG1pbmZyZWUpCisJCXJl dHVybiAoRUlOVkFMKTsKKwlpZiAodmFsID4gY250LnZfcGFnZV9jb3VudCkKKwkJcmV0dXJuIChF SU5WQUwpOworCisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZhbDsKKworCXJldHVybiAoMCk7Cit9 CisjZW5kaWYKKwogLyoKICAqIE5vdGUgdGhhdCBidWZmZXJzIGNhbiBiZSBpbiBvbmUgb2YgNiBz dGF0ZXM6CiAgKglBUkNfYW5vbgktIGFub255bW91cyAoZGlzY3Vzc2VkIGJlbG93KQpAQCAtMjQy MSw5ICsyNDYxLDEyIEBAIGFyY19mbHVzaChzcGFfdCAqc3BhKQogdm9pZAogYXJjX3Nocmluayh2 b2lkKQogeworCiAJaWYgKGFyY19jID4gYXJjX2NfbWluKSB7CiAJCXVpbnQ2NF90IHRvX2ZyZWU7 CiAKKwkJRFRSQUNFX1BST0JFMihhcmNfX3NocmluaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRf dCwKKwkJCWFyY19jX21pbik7CiAjaWZkZWYgX0tFUk5FTAogCQl0b19mcmVlID0gYXJjX2MgPj4g YXJjX3Nocmlua19zaGlmdDsKICNlbHNlCkBAIC0yNDQzLDggKzI0ODYsMTEgQEAgYXJjX3Nocmlu ayh2b2lkKQogCQlBU1NFUlQoKGludDY0X3QpYXJjX3AgPj0gMCk7CiAJfQogCi0JaWYgKGFyY19z aXplID4gYXJjX2MpCisJaWYgKGFyY19zaXplID4gYXJjX2MpIHsKKwkJRFRSQUNFX1BST0JFMihh cmNfX3Nocmlua19hZGp1c3QsIHVpbnQ2NF90LCBhcmNfc2l6ZSwKKwkJCXVpbnQ2NF90LCBhcmNf Yyk7CiAJCWFyY19hZGp1c3QoKTsKKwl9CiB9CiAKIHN0YXRpYyBpbnQgbmVlZGZyZWUgPSAwOwpA QCAtMjQ1NSwxNSArMjUwMSwyMCBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIAogI2lmZGVm IF9LRVJORUwKIAotCWlmIChuZWVkZnJlZSkKKwlpZiAobmVlZGZyZWUpIHsKKwkJRFRSQUNFX1BS T0JFKGFyY19fcmVjbGFpbV9uZWVkZnJlZSk7CiAJCXJldHVybiAoMSk7CisJfQogCiAJLyoKIAkg KiBDb29wZXJhdGUgd2l0aCBwYWdlZGFlbW9uIHdoZW4gaXQncyB0aW1lIGZvciBpdCB0byBzY2Fu CiAJICogYW5kIHJlY2xhaW0gc29tZSBwYWdlcy4KIAkgKi8KLQlpZiAodm1fcGFnaW5nX25lZWRl ZCgpKQorCWlmIChmcmVlbWVtIDwgemZzX2FyY19mcmVlX3RhcmdldCkgeworCQlEVFJBQ0VfUFJP QkUyKGFyY19fcmVjbGFpbV9mcmVlbWVtLCB1aW50NjRfdCwKKwkJICAgIGZyZWVtZW0sIHVpbnQ2 NF90LCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KTsKIAkJcmV0dXJuICgxKTsKKwl9CiAKICNpZmRlZiBz dW4KIAkvKgpAQCAtMjQ5MSw4ICsyNTQyLDE5IEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQog CWlmIChhdmFpbHJtZW0gPCBzd2FwZnNfbWluZnJlZSArIHN3YXBmc19yZXNlcnZlICsgZXh0cmEp CiAJCXJldHVybiAoMSk7CiAKLSNpZiBkZWZpbmVkKF9faTM4NikKIAkvKgorCSAqIENoZWNrIHRo YXQgd2UgaGF2ZSBlbm91Z2ggYXZhaWxybWVtIHRoYXQgbWVtb3J5IGxvY2tpbmcgKGUuZy4sIHZp YQorCSAqIG1sb2NrKDNDKSBvciBtZW1jbnRsKDIpKSBjYW4gc3RpbGwgc3VjY2VlZC4gIChwYWdl c19wcF9tYXhpbXVtCisJICogc3RvcmVzIHRoZSBudW1iZXIgb2YgcGFnZXMgdGhhdCBjYW5ub3Qg YmUgbG9ja2VkOyB3aGVuIGF2YWlscm1lbQorCSAqIGRyb3BzIGJlbG93IHBhZ2VzX3BwX21heGlt dW0sIHBhZ2UgbG9ja2luZyBtZWNoYW5pc21zIHN1Y2ggYXMKKwkgKiBwYWdlX3BwX2xvY2soKSB3 aWxsIGZhaWwuKQorCSAqLworCWlmIChhdmFpbHJtZW0gPD0gcGFnZXNfcHBfbWF4aW11bSkKKwkJ cmV0dXJuICgxKTsKKworI2VuZGlmCS8qIHN1biAqLworI2lmIGRlZmluZWQoX19pMzg2KSB8fCAh ZGVmaW5lZChVTUFfTURfU01BTExfQUxMT0MpCisJLyoKIAkgKiBJZiB3ZSdyZSBvbiBhbiBpMzg2 IHBsYXRmb3JtLCBpdCdzIHBvc3NpYmxlIHRoYXQgd2UnbGwgZXhoYXVzdCB0aGUKIAkgKiBrZXJu ZWwgaGVhcCBzcGFjZSBiZWZvcmUgd2UgZXZlciBydW4gb3V0IG9mIGF2YWlsYWJsZSBwaHlzaWNh bAogCSAqIG1lbW9yeS4gIE1vc3QgY2hlY2tzIG9mIHRoZSBzaXplIG9mIHRoZSBoZWFwX2FyZWEg Y29tcGFyZSBhZ2FpbnN0CkBAIC0yNTAzLDE5ICsyNTY1LDM1IEBAIGFyY19yZWNsYWltX25lZWRl ZCh2b2lkKQogCSAqIGhlYXAgaXMgYWxsb2NhdGVkLiAgKE9yLCBpbiB0aGUgY2FsY3VsYXRpb24s IGlmIGxlc3MgdGhhbiAxLzR0aCBpcwogCSAqIGZyZWUpCiAJICovCi0JaWYgKGJ0b3Aodm1lbV9z aXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkpIDwKLQkgICAgKGJ0b3Aodm1lbV9zaXplKGhlYXBf YXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+PiAyKSkKKwlpZiAodm1lbV9zaXplKGhl YXBfYXJlbmEsIFZNRU1fRlJFRSkgPAorCSAgICAodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1f RlJFRSB8IFZNRU1fQUxMT0MpID4+IDIpKSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19yZWNsYWlt X3VzZWQsIHVpbnQ2NF90LAorCQkgICAgdm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSks IHVpbnQ2NF90LAorCQkgICAgKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUgfCBWTUVN X0FMTE9DKSkgPj4gMik7CiAJCXJldHVybiAoMSk7CisJfQogI2VuZGlmCi0jZWxzZQkvKiAhc3Vu ICovCi0JaWYgKGttZW1fdXNlZCgpID4gKGttZW1fc2l6ZSgpICogMykgLyA0KQorI2lmZGVmIHN1 bgorCS8qCisJICogSWYgemlvIGRhdGEgcGFnZXMgYXJlIGJlaW5nIGFsbG9jYXRlZCBvdXQgb2Yg YSBzZXBhcmF0ZSBoZWFwIHNlZ21lbnQsCisJICogdGhlbiBlbmZvcmNlIHRoYXQgdGhlIHNpemUg b2YgYXZhaWxhYmxlIHZtZW0gZm9yIHRoaXMgYXJlbmEgcmVtYWlucworCSAqIGFib3ZlIGFib3V0 IDEvMTZ0aCBmcmVlLgorCSAqCisJICogTm90ZTogVGhlIDEvMTZ0aCBhcmVuYSBmcmVlIHJlcXVp cmVtZW50IHdhcyBwdXQgaW4gcGxhY2UKKwkgKiB0byBhZ2dyZXNzaXZlbHkgZXZpY3QgbWVtb3J5 IGZyb20gdGhlIGFyYyBpbiBvcmRlciB0byBhdm9pZAorCSAqIG1lbW9yeSBmcmFnbWVudGF0aW9u IGlzc3Vlcy4KKwkgKi8KKwlpZiAoemlvX2FyZW5hICE9IE5VTEwgJiYKKwkgICAgdm1lbV9zaXpl KHppb19hcmVuYSwgVk1FTV9GUkVFKSA8CisJICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVN X0FMTE9DKSA+PiA0KSkKIAkJcmV0dXJuICgxKTsKICNlbmRpZgkvKiBzdW4gKi8KLQotI2Vsc2UK KyNlbHNlCS8qIF9LRVJORUwgKi8KIAlpZiAoc3BhX2dldF9yYW5kb20oMTAwKSA9PSAwKQogCQly ZXR1cm4gKDEpOwotI2VuZGlmCisjZW5kaWYJLyogX0tFUk5FTCAqLworCURUUkFDRV9QUk9CRShh cmNfX3JlY2xhaW1fbm8pOworCiAJcmV0dXJuICgwKTsKIH0KIApAQCAtMjU2NCw2ICsyNjQyLDE1 IEBAIGFyY19rbWVtX3JlYXBfbm93KGFyY19yZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJfQog CWttZW1fY2FjaGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKIAlrbWVtX2NhY2hlX3JlYXBfbm93KGhk cl9jYWNoZSk7CisKKyNpZmRlZiBzdW4KKwkvKgorCSAqIEFzayB0aGUgdm1lbSBhcmVhbmEgdG8g cmVjbGFpbSB1bnVzZWQgbWVtb3J5IGZyb20gaXRzCisJICogcXVhbnR1bSBjYWNoZXMuCisJICov CisJaWYgKHppb19hcmVuYSAhPSBOVUxMICYmIHN0cmF0ID09IEFSQ19SRUNMQUlNX0FHR1IpCisJ CXZtZW1fcWNhY2hlX3JlYXAoemlvX2FyZW5hKTsKKyNlbmRpZgogfQogCiBzdGF0aWMgdm9pZApA QCAtMjcxMywyMCArMjgwMCw2IEBAIGFyY19ldmljdF9uZWVkZWQoYXJjX2J1Zl9jb250ZW50c190 IHR5cGUpCiAJaWYgKHR5cGUgPT0gQVJDX0JVRkNfTUVUQURBVEEgJiYgYXJjX21ldGFfdXNlZCA+ PSBhcmNfbWV0YV9saW1pdCkKIAkJcmV0dXJuICgxKTsKIAotI2lmZGVmIHN1bgotI2lmZGVmIF9L RVJORUwKLQkvKgotCSAqIElmIHppbyBkYXRhIHBhZ2VzIGFyZSBiZWluZyBhbGxvY2F0ZWQgb3V0 IG9mIGEgc2VwYXJhdGUgaGVhcCBzZWdtZW50LAotCSAqIHRoZW4gZW5mb3JjZSB0aGF0IHRoZSBz aXplIG9mIGF2YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFyZWEgcmVtYWlucwotCSAqIGFib3ZlIGFi b3V0IDEvMzJuZCBmcmVlLgotCSAqLwotCWlmICh0eXBlID09IEFSQ19CVUZDX0RBVEEgJiYgemlv X2FyZW5hICE9IE5VTEwgJiYKLQkgICAgdm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9GUkVFKSA8 Ci0JICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0FMTE9DKSA+PiA1KSkKLQkJcmV0dXJu ICgxKTsKLSNlbmRpZgotI2VuZGlmCS8qIHN1biAqLwotCiAJaWYgKGFyY19yZWNsYWltX25lZWRl ZCgpKQogCQlyZXR1cm4gKDEpOwogCkBAIC0zODg1LDIwICszOTU4LDE2IEBAIHN0YXRpYyBpbnQK IGFyY19tZW1vcnlfdGhyb3R0bGUodWludDY0X3QgcmVzZXJ2ZSwgdWludDY0X3QgdHhnKQogewog I2lmZGVmIF9LRVJORUwKLQl1aW50NjRfdCBhdmFpbGFibGVfbWVtb3J5ID0KLQkgICAgcHRvYSgo dWludG1heF90KWNudC52X2ZyZWVfY291bnQgKyBjbnQudl9jYWNoZV9jb3VudCk7CisJdWludDY0 X3QgYXZhaWxhYmxlX21lbW9yeSA9IHB0b2IoZnJlZW1lbSk7CiAJc3RhdGljIHVpbnQ2NF90IHBh Z2VfbG9hZCA9IDA7CiAJc3RhdGljIHVpbnQ2NF90IGxhc3RfdHhnID0gMDsKIAotI2lmZGVmIHN1 bgotI2lmIGRlZmluZWQoX19pMzg2KQorI2lmIGRlZmluZWQoX19pMzg2KSB8fCAhZGVmaW5lZChV TUFfTURfU01BTExfQUxMT0MpCiAJYXZhaWxhYmxlX21lbW9yeSA9Ci0JICAgIE1JTihhdmFpbGFi bGVfbWVtb3J5LCB2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSk7CisJICAgIE1JTihh dmFpbGFibGVfbWVtb3J5LCBwdG9iKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpKSk7 CiAjZW5kaWYKLSNlbmRpZgkvKiBzdW4gKi8KIAotCWlmIChjbnQudl9mcmVlX2NvdW50ICsgY250 LnZfY2FjaGVfY291bnQgPgotCSAgICAodWludDY0X3QpcGh5c21lbSAqIGFyY19sb3RzZnJlZV9w ZXJjZW50IC8gMTAwKQorCWlmIChmcmVlbWVtID4gKHVpbnQ2NF90KXBoeXNtZW0gKiBhcmNfbG90 c2ZyZWVfcGVyY2VudCAvIDEwMCkKIAkJcmV0dXJuICgwKTsKIAogCWlmICh0eGcgPiBsYXN0X3R4 ZykgewpAQCAtMzkxMSw3ICszOTgwLDcgQEAgYXJjX21lbW9yeV90aHJvdHRsZSh1aW50NjRfdCBy ZXNlcnZlLCB1aW50NjRfdCB0eGcKIAkgKiBjb250aW51ZSB0byBsZXQgcGFnZSB3cml0ZXMgb2Nj dXIgYXMgcXVpY2tseSBhcyBwb3NzaWJsZS4KIAkgKi8KIAlpZiAoY3VycHJvYyA9PSBwYWdlcHJv YykgewotCQlpZiAocGFnZV9sb2FkID4gYXZhaWxhYmxlX21lbW9yeSAvIDQpCisJCWlmIChwYWdl X2xvYWQgPiBNQVgocHRvYihtaW5mcmVlKSwgYXZhaWxhYmxlX21lbW9yeSkgLyA0KQogCQkJcmV0 dXJuIChTRVRfRVJST1IoRVJFU1RBUlQpKTsKIAkJLyogTm90ZTogcmVzZXJ2ZSBpcyBpbmZsYXRl ZCwgc28gd2UgZGVmbGF0ZSAqLwogCQlwYWdlX2xvYWQgKz0gcmVzZXJ2ZSAvIDg7CkluZGV4OiBz eXMvdm0vdm1fcGFnZW91dC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy92bS92bV9wYWdlb3V0LmMJKHJl dmlzaW9uIDI3MTExNikKKysrIHN5cy92bS92bV9wYWdlb3V0LmMJKHdvcmtpbmcgY29weSkKQEAg LTExNSwxMCArMTE1LDE0IEBAIF9fRkJTRElEKCIkRnJlZUJTRCQiKTsKIAogLyogdGhlIGtlcm5l bCBwcm9jZXNzICJ2bV9wYWdlb3V0IiovCiBzdGF0aWMgdm9pZCB2bV9wYWdlb3V0KHZvaWQpOwor c3RhdGljIHZvaWQgdm1fcGFnZW91dF9pbml0KHZvaWQpOwogc3RhdGljIGludCB2bV9wYWdlb3V0 X2NsZWFuKHZtX3BhZ2VfdCk7CiBzdGF0aWMgdm9pZCB2bV9wYWdlb3V0X3NjYW4oc3RydWN0IHZt X2RvbWFpbiAqdm1kLCBpbnQgcGFzcyk7CiBzdGF0aWMgdm9pZCB2bV9wYWdlb3V0X21pZ2h0YmVf b29tKHN0cnVjdCB2bV9kb21haW4gKnZtZCwgaW50IHBhc3MpOwogCitTWVNJTklUKHBhZ2VkYWVt b25faW5pdCwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfRklSU1QsIHZtX3BhZ2VvdXRf aW5pdCwKKyAgICBOVUxMKTsKKwogc3RydWN0IHByb2MgKnBhZ2Vwcm9jOwogCiBzdGF0aWMgc3Ry dWN0IGtwcm9jX2Rlc2MgcGFnZV9rcCA9IHsKQEAgLTEyNiw3ICsxMzAsNyBAQCBzdGF0aWMgc3Ry dWN0IGtwcm9jX2Rlc2MgcGFnZV9rcCA9IHsKIAl2bV9wYWdlb3V0LAogCSZwYWdlcHJvYwogfTsK LVNZU0lOSVQocGFnZWRhZW1vbiwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfRklSU1Qs IGtwcm9jX3N0YXJ0LAorU1lTSU5JVChwYWdlZGFlbW9uLCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBT SV9PUkRFUl9TRUNPTkQsIGtwcm9jX3N0YXJ0LAogICAgICZwYWdlX2twKTsKIAogI2lmICFkZWZp bmVkKE5PX1NXQVBQSU5HKQpAQCAtMTY1MCwxNSArMTY1NCwxMSBAQCB2bV9wYWdlb3V0X3dvcmtl cih2b2lkICphcmcpCiB9CiAKIC8qCi0gKgl2bV9wYWdlb3V0IGlzIHRoZSBoaWdoIGxldmVsIHBh Z2VvdXQgZGFlbW9uLgorICoJdm1fcGFnZW91dF9pbml0IGluaXRpYWxpc2VzIGJhc2ljIHBhZ2Vv dXQgZGFlbW9uIHNldHRpbmdzLgogICovCiBzdGF0aWMgdm9pZAotdm1fcGFnZW91dCh2b2lkKQor dm1fcGFnZW91dF9pbml0KHZvaWQpCiB7Ci0jaWYgTUFYTUVNRE9NID4gMQotCWludCBlcnJvciwg aTsKLSNlbmRpZgotCiAJLyoKIAkgKiBJbml0aWFsaXplIHNvbWUgcGFnaW5nIHBhcmFtZXRlcnMu CiAJICovCkBAIC0xNzA0LDcgKzE3MDQsMTggQEAgc3RhdGljIHZvaWQKIAkvKiBYWFggZG9lcyBu b3QgcmVhbGx5IGJlbG9uZyBoZXJlICovCiAJaWYgKHZtX3BhZ2VfbWF4X3dpcmVkID09IDApCiAJ CXZtX3BhZ2VfbWF4X3dpcmVkID0gY250LnZfZnJlZV9jb3VudCAvIDM7Cit9CiAKKy8qCisgKiAg ICAgdm1fcGFnZW91dCBpcyB0aGUgaGlnaCBsZXZlbCBwYWdlb3V0IGRhZW1vbi4KKyAqLworc3Rh dGljIHZvaWQKK3ZtX3BhZ2VvdXQodm9pZCkKK3sKKyNpZiBNQVhNRU1ET00gPiAxCisJaW50IGVy cm9yLCBpOworI2VuZGlmCisKIAlzd2FwX3BhZ2VyX3N3YXBfaW5pdCgpOwogI2lmIE1BWE1FTURP TSA+IDEKIAlmb3IgKGkgPSAxOyBpIDwgdm1fbmRvbWFpbnM7IGkrKykgewo= 146861 2014-09-05 11:46:32 +0000 2014-09-08 15:29:46 +0000 arc reclam refactor (against head) arc-reclaim-head.patch text/plain 9278 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MDg3NSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTI2LDQyICsx MjYsNiBAQCBrbWVtX3NpemVfaW5pdCh2b2lkICp1bnVzZWQgX191bnVzZWQpCiB9CiBTWVNJTklU KGttZW1fc2l6ZV9pbml0LCBTSV9TVUJfS01FTSwgU0lfT1JERVJfQU5ZLCBrbWVtX3NpemVfaW5p dCwgTlVMTCk7CiAKLS8qCi0gKiBUaGUgcmV0dXJuIHZhbHVlcyBmcm9tIGttZW1fZnJlZV8qIGFy ZSBvbmx5IHZhbGlkIG9uY2UgdGhlIHBhZ2VkYWVtb24KLSAqIGhhcyBiZWVuIGluaXRpYWxpc2Vk LCBiZWZvcmUgdGhlbiB0aGV5IHJldHVybiAwLgotICogCi0gKiBUbyBlbnN1cmUgdGhlIHJldHVy bnMgYXJlIHZhbGlkIHRoZSBjYWxsZXIgY2FuIHVzZSBhIFNZU0lOSVQgd2l0aAotICogc3Vic3lz dGVtIHNldCB0byBTSV9TVUJfS1RIUkVBRF9QQUdFIGFuZCBhbiBvcmRlciBvZiBhdCBsZWFzdAot ICogU0lfT1JERVJfU0VDT05ELgotICovCi11X2ludAota21lbV9mcmVlX3RhcmdldCh2b2lkKQot ewotCi0JcmV0dXJuICh2bV9jbnQudl9mcmVlX3RhcmdldCk7Ci19Ci0KLXVfaW50Ci1rbWVtX2Zy ZWVfbWluKHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtX2NudC52X2ZyZWVfbWluKTsKLX0KLQotdV9p bnQKLWttZW1fZnJlZV9jb3VudCh2b2lkKQotewotCi0JcmV0dXJuICh2bV9jbnQudl9mcmVlX2Nv dW50ICsgdm1fY250LnZfY2FjaGVfY291bnQpOwotfQotCi11X2ludAota21lbV9wYWdlX2NvdW50 KHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtX2NudC52X3BhZ2VfY291bnQpOwotfQotCiB1aW50NjRf dAoga21lbV9zaXplKHZvaWQpCiB7CkBAIC0xNjksMTMgKzEzMyw2IEBAIGttZW1fc2l6ZSh2b2lk KQogCXJldHVybiAoa21lbV9zaXplX3ZhbCk7CiB9CiAKLXVpbnQ2NF90Ci1rbWVtX3VzZWQodm9p ZCkKLXsKLQotCXJldHVybiAodm1lbV9zaXplKGttZW1fYXJlbmEsIFZNRU1fQUxMT0MpKTsKLX0K LQogc3RhdGljIGludAoga21lbV9zdGRfY29uc3RydWN0b3Iodm9pZCAqbWVtLCBpbnQgc2l6ZSBf X3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgaW50IGZsYWdzKQogewpJbmRleDogc3lzL2NkZGwvY29t cGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29tcGF0 L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgJKHJldmlzaW9uIDI3MDg3NSkKKysrIHN5cy9jZGRsL2Nv bXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCSh3b3JraW5nIGNvcHkpCkBAIC02NiwxNyArNjYs NiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZvaWQgKnpmc19rbWVtX2FsbG9jKHNp emVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19rbWVtX2ZyZWUodm9pZCAqYnVmLCBz aXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9pZCk7Ci11aW50NjRfdCBrbWVtX3Vz ZWQodm9pZCk7Ci11X2ludCBrbWVtX3BhZ2VfY291bnQodm9pZCk7Ci0KLS8qCi0gKiBUaGUgcmV0 dXJuIHZhbHVlcyBmcm9tIGttZW1fZnJlZV8qIGFyZSBvbmx5IHZhbGlkIG9uY2UgdGhlIHBhZ2Vk YWVtb24KLSAqIGhhcyBiZWVuIGluaXRpYWxpc2VkLCBiZWZvcmUgdGhlbiB0aGV5IHJldHVybiAw LgotICovCi11X2ludCBrbWVtX2ZyZWVfY291bnQodm9pZCk7Ci11X2ludCBrbWVtX2ZyZWVfdGFy Z2V0KHZvaWQpOwotdV9pbnQga21lbV9mcmVlX21pbih2b2lkKTsKLQoga21lbV9jYWNoZV90ICpr bWVtX2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3QgYnVmc2l6ZSwgc2l6ZV90IGFsaWdu LAogICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZvaWQgKiwgaW50KSwgdm9pZCAoKmRl c3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lkICgqcmVjbGFpbSkodm9pZCAqKSBf X3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAsIGludCBjZmxhZ3MpOwpAQCAtODgs NiArNzcsOSBAQCB2b2lkIGttZW1fcmVhcCh2b2lkKTsKIGludCBrbWVtX2RlYnVnZ2luZyh2b2lk KTsKIHZvaWQgKmNhbGxvYyhzaXplX3Qgbiwgc2l6ZV90IHMpOwogCisjZGVmaW5lCWZyZWVtZW0J CQkJKHZtX2NudC52X2ZyZWVfY291bnQgKyB2bV9jbnQudl9jYWNoZV9jb3VudCkKKyNkZWZpbmUJ bWluZnJlZQkJCQl2bV9jbnQudl9mcmVlX21pbgorI2RlZmluZQloZWFwX2FyZW5hCQkJa21lbV9h cmVuYQogI2RlZmluZQlrbWVtX2FsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChz aXplKSwgKGttZmxhZ3MpKQogI2RlZmluZQlrbWVtX3phbGxvYyhzaXplLCBrbWZsYWdzKQl6ZnNf a21lbV9hbGxvYygoc2l6ZSksIChrbWZsYWdzKSB8IE1fWkVSTykKICNkZWZpbmUJa21lbV9mcmVl KGJ1Ziwgc2l6ZSkJCXpmc19rbWVtX2ZyZWUoKGJ1ZiksIChzaXplKSkKSW5kZXg6IHN5cy9jZGRs L2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvYXJjLmMKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwko cmV2aXNpb24gMjcwODc1KQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29t bW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMTM4LDYgKzEzOCw3IEBACiAjaW5j bHVkZSA8c3lzL3NkdC5oPgogCiAjaW5jbHVkZSA8dm0vdm1fcGFnZW91dC5oPgorI2luY2x1ZGUg PG1hY2hpbmUvdm1wYXJhbS5oPgogCiAjaWZkZWYgaWxsdW1vcwogI2lmbmRlZiBfS0VSTkVMCkBA IC0yMDEsNyArMjAyLDcgQEAgaW50IHpmc19hcmNfc2hyaW5rX3NoaWZ0ID0gMDsKIGludCB6ZnNf YXJjX3BfbWluX3NoaWZ0ID0gMDsKIGludCB6ZnNfZGlzYWJsZV9kdXBfZXZpY3Rpb24gPSAwOwog dWludDY0X3QgemZzX2FyY19hdmVyYWdlX2Jsb2Nrc2l6ZSA9IDggKiAxMDI0OyAvKiA4S0IgKi8K LXVfaW50IHpmc19hcmNfZnJlZV90YXJnZXQgPSAoMSA8PCAxOSk7IC8qIGRlZmF1bHQgYmVmb3Jl IHBhZ2VkYWVtb24gaW5pdCBvbmx5ICovCit1X2ludCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gKDEg PDwgMTYpOyAvKiBkZWZhdWx0IGJlZm9yZSBwYWdlZGFlbW9uIGluaXQgb25seSAqLwogCiBzdGF0 aWMgaW50IHN5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldChTWVNDVExfSEFORExFUl9BUkdT KTsKIApAQCAtMjEwLDExICsyMTEsMTAgQEAgc3RhdGljIHZvaWQKIGFyY19mcmVlX3RhcmdldF9p bml0KHZvaWQgKnVudXNlZCBfX3VudXNlZCkKIHsKIAotCXpmc19hcmNfZnJlZV90YXJnZXQgPSBr bWVtX2ZyZWVfdGFyZ2V0KCk7CisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2VvdXRfd2Fr ZXVwX3RocmVzaDsKIH0KIFNZU0lOSVQoYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhS RUFEX1BBR0UsIFNJX09SREVSX0FOWSwKICAgICBhcmNfZnJlZV90YXJnZXRfaW5pdCwgTlVMTCk7 Ci0jZW5kaWYKIAogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19tZXRhX2xpbWl0IiwgJnpmc19h cmNfbWV0YV9saW1pdCk7CiBTWVNDVExfREVDTChfdmZzX3pmcyk7CkBAIC0yNDUsOSArMjQ1LDkg QEAgc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0KFNZU0NUTF9IQU5ETEVSX0FSR1MKIAlp ZiAoZXJyICE9IDAgfHwgcmVxLT5uZXdwdHIgPT0gTlVMTCkKIAkJcmV0dXJuIChlcnIpOwogCi0J aWYgKHZhbCA8IGttZW1fZnJlZV9taW4oKSkKKwlpZiAodmFsIDwgbWluZnJlZSkKIAkJcmV0dXJu IChFSU5WQUwpOwotCWlmICh2YWwgPiBrbWVtX3BhZ2VfY291bnQoKSkKKwlpZiAodmFsID4gdm1f Y250LnZfcGFnZV9jb3VudCkKIAkJcmV0dXJuIChFSU5WQUwpOwogCiAJemZzX2FyY19mcmVlX3Rh cmdldCA9IHZhbDsKQEAgLTI1NCw2ICsyNTQsNyBAQCBzeXNjdGxfdmZzX3pmc19hcmNfZnJlZV90 YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUwogCiAJcmV0dXJuICgwKTsKIH0KKyNlbmRpZgogCiAv KgogICogTm90ZSB0aGF0IGJ1ZmZlcnMgY2FuIGJlIGluIG9uZSBvZiA2IHN0YXRlczoKQEAgLTI1 MDMsMTggKzI1MDQsMTMgQEAgYXJjX3JlY2xhaW1fbmVlZGVkKHZvaWQpCiAJCXJldHVybiAoMSk7 CiAJfQogCi0JaWYgKGttZW1fZnJlZV9jb3VudCgpIDwgemZzX2FyY19mcmVlX3RhcmdldCkgewot CQlEVFJBQ0VfUFJPQkUyKGFyY19fcmVjbGFpbV9mcmVldGFyZ2V0LCB1aW50NjRfdCwKLQkJICAg IGttZW1fZnJlZV9jb3VudCgpLCB1aW50NjRfdCwgemZzX2FyY19mcmVlX3RhcmdldCk7Ci0JCXJl dHVybiAoMSk7Ci0JfQotCiAJLyoKIAkgKiBDb29wZXJhdGUgd2l0aCBwYWdlZGFlbW9uIHdoZW4g aXQncyB0aW1lIGZvciBpdCB0byBzY2FuCiAJICogYW5kIHJlY2xhaW0gc29tZSBwYWdlcy4KIAkg Ki8KLQlpZiAodm1fcGFnaW5nX25lZWRlZCgpKSB7Ci0JCURUUkFDRV9QUk9CRShhcmNfX3JlY2xh aW1fcGFnaW5nKTsKKwlpZiAoZnJlZW1lbSA8IHpmc19hcmNfZnJlZV90YXJnZXQpIHsKKwkJRFRS QUNFX1BST0JFMihhcmNfX3JlY2xhaW1fZnJlZW1lbSwgdWludDY0X3QsCisJCSAgICBmcmVlbWVt LCB1aW50NjRfdCwgemZzX2FyY19mcmVlX3RhcmdldCk7CiAJCXJldHVybiAoMSk7CiAJfQogCkBA IC0yNTQ0LDggKzI1NDAsMTkgQEAgYXJjX3JlY2xhaW1fbmVlZGVkKHZvaWQpCiAJaWYgKGF2YWls cm1lbSA8IHN3YXBmc19taW5mcmVlICsgc3dhcGZzX3Jlc2VydmUgKyBleHRyYSkKIAkJcmV0dXJu ICgxKTsKIAotI2lmIGRlZmluZWQoX19pMzg2KQogCS8qCisJICogQ2hlY2sgdGhhdCB3ZSBoYXZl IGVub3VnaCBhdmFpbHJtZW0gdGhhdCBtZW1vcnkgbG9ja2luZyAoZS5nLiwgdmlhCisJICogbWxv Y2soM0MpIG9yIG1lbWNudGwoMikpIGNhbiBzdGlsbCBzdWNjZWVkLiAgKHBhZ2VzX3BwX21heGlt dW0KKwkgKiBzdG9yZXMgdGhlIG51bWJlciBvZiBwYWdlcyB0aGF0IGNhbm5vdCBiZSBsb2NrZWQ7 IHdoZW4gYXZhaWxybWVtCisJICogZHJvcHMgYmVsb3cgcGFnZXNfcHBfbWF4aW11bSwgcGFnZSBs b2NraW5nIG1lY2hhbmlzbXMgc3VjaCBhcworCSAqIHBhZ2VfcHBfbG9jaygpIHdpbGwgZmFpbC4p CisJICovCisJaWYgKGF2YWlscm1lbSA8PSBwYWdlc19wcF9tYXhpbXVtKQorCQlyZXR1cm4gKDEp OworCisjZW5kaWYJLyogc3VuICovCisjaWYgZGVmaW5lZChfX2kzODYpIHx8ICFkZWZpbmVkKFVN QV9NRF9TTUFMTF9BTExPQykKKwkvKgogCSAqIElmIHdlJ3JlIG9uIGFuIGkzODYgcGxhdGZvcm0s IGl0J3MgcG9zc2libGUgdGhhdCB3ZSdsbCBleGhhdXN0IHRoZQogCSAqIGtlcm5lbCBoZWFwIHNw YWNlIGJlZm9yZSB3ZSBldmVyIHJ1biBvdXQgb2YgYXZhaWxhYmxlIHBoeXNpY2FsCiAJICogbWVt b3J5LiAgTW9zdCBjaGVja3Mgb2YgdGhlIHNpemUgb2YgdGhlIGhlYXBfYXJlYSBjb21wYXJlIGFn YWluc3QKQEAgLTI1NTYsMjUgKzI1NjMsMzMgQEAgYXJjX3JlY2xhaW1fbmVlZGVkKHZvaWQpCiAJ ICogaGVhcCBpcyBhbGxvY2F0ZWQuICAoT3IsIGluIHRoZSBjYWxjdWxhdGlvbiwgaWYgbGVzcyB0 aGFuIDEvNHRoIGlzCiAJICogZnJlZSkKIAkgKi8KLQlpZiAoYnRvcCh2bWVtX3NpemUoaGVhcF9h cmVuYSwgVk1FTV9GUkVFKSkgPAotCSAgICAoYnRvcCh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1F TV9GUkVFIHwgVk1FTV9BTExPQykpID4+IDIpKQotCQlyZXR1cm4gKDEpOwotI2VuZGlmCi0jZWxz ZQkvKiBzdW4gKi8KLSNpZmRlZiBfX2kzODZfXwotCS8qIGkzODYgaGFzIEtWQSBsaW1pdHMgdGhh dCB0aGUgcmF3IHBhZ2UgY291bnRzIGFib3ZlIGRvbid0IGNvbnNpZGVyICovCi0JaWYgKGttZW1f dXNlZCgpID4gKGttZW1fc2l6ZSgpICogMykgLyA0KSB7CisJaWYgKHZtZW1fc2l6ZShoZWFwX2Fy ZW5hLCBWTUVNX0ZSRUUpIDwKKwkgICAgKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUg fCBWTUVNX0FMTE9DKSA+PiAyKSkgewogCQlEVFJBQ0VfUFJPQkUyKGFyY19fcmVjbGFpbV91c2Vk LCB1aW50NjRfdCwKLQkJICAgIGttZW1fdXNlZCgpLCB1aW50NjRfdCwgKGttZW1fc2l6ZSgpICog MykgLyA0KTsKKwkJICAgIHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpLCB1aW50NjRf dCwKKwkJICAgICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwgVk1FTV9BTExPQykp ID4+IDIpOwogCQlyZXR1cm4gKDEpOwogCX0KICNlbmRpZgorI2lmZGVmIHN1bgorCS8qCisJICog SWYgemlvIGRhdGEgcGFnZXMgYXJlIGJlaW5nIGFsbG9jYXRlZCBvdXQgb2YgYSBzZXBhcmF0ZSBo ZWFwIHNlZ21lbnQsCisJICogdGhlbiBlbmZvcmNlIHRoYXQgdGhlIHNpemUgb2YgYXZhaWxhYmxl IHZtZW0gZm9yIHRoaXMgYXJlbmEgcmVtYWlucworCSAqIGFib3ZlIGFib3V0IDEvMTZ0aCBmcmVl LgorCSAqCisJICogTm90ZTogVGhlIDEvMTZ0aCBhcmVuYSBmcmVlIHJlcXVpcmVtZW50IHdhcyBw dXQgaW4gcGxhY2UKKwkgKiB0byBhZ2dyZXNzaXZlbHkgZXZpY3QgbWVtb3J5IGZyb20gdGhlIGFy YyBpbiBvcmRlciB0byBhdm9pZAorCSAqIG1lbW9yeSBmcmFnbWVudGF0aW9uIGlzc3Vlcy4KKwkg Ki8KKwlpZiAoemlvX2FyZW5hICE9IE5VTEwgJiYKKwkgICAgdm1lbV9zaXplKHppb19hcmVuYSwg Vk1FTV9GUkVFKSA8CisJICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0FMTE9DKSA+PiA0 KSkKKwkJcmV0dXJuICgxKTsKICNlbmRpZgkvKiBzdW4gKi8KLQotI2Vsc2UKKyNlbHNlCS8qIF9L RVJORUwgKi8KIAlpZiAoc3BhX2dldF9yYW5kb20oMTAwKSA9PSAwKQogCQlyZXR1cm4gKDEpOwot I2VuZGlmCisjZW5kaWYJLyogX0tFUk5FTCAqLwogCURUUkFDRV9QUk9CRShhcmNfX3JlY2xhaW1f bm8pOwogCiAJcmV0dXJuICgwKTsKQEAgLTI2MjUsNiArMjY0MCwxNSBAQCBhcmNfa21lbV9yZWFw X25vdyhhcmNfcmVjbGFpbV9zdHJhdGVneV90IHN0cmF0KQogCX0KIAlrbWVtX2NhY2hlX3JlYXBf bm93KGJ1Zl9jYWNoZSk7CiAJa21lbV9jYWNoZV9yZWFwX25vdyhoZHJfY2FjaGUpOworCisjaWZk ZWYgc3VuCisJLyoKKwkgKiBBc2sgdGhlIHZtZW0gYXJlYW5hIHRvIHJlY2xhaW0gdW51c2VkIG1l bW9yeSBmcm9tIGl0cworCSAqIHF1YW50dW0gY2FjaGVzLgorCSAqLworCWlmICh6aW9fYXJlbmEg IT0gTlVMTCAmJiBzdHJhdCA9PSBBUkNfUkVDTEFJTV9BR0dSKQorCQl2bWVtX3FjYWNoZV9yZWFw KHppb19hcmVuYSk7CisjZW5kaWYKIH0KIAogc3RhdGljIHZvaWQKQEAgLTI3NzQsMjAgKzI3OTgs NiBAQCBhcmNfZXZpY3RfbmVlZGVkKGFyY19idWZfY29udGVudHNfdCB0eXBlKQogCWlmICh0eXBl ID09IEFSQ19CVUZDX01FVEFEQVRBICYmIGFyY19tZXRhX3VzZWQgPj0gYXJjX21ldGFfbGltaXQp CiAJCXJldHVybiAoMSk7CiAKLSNpZmRlZiBzdW4KLSNpZmRlZiBfS0VSTkVMCi0JLyoKLQkgKiBJ ZiB6aW8gZGF0YSBwYWdlcyBhcmUgYmVpbmcgYWxsb2NhdGVkIG91dCBvZiBhIHNlcGFyYXRlIGhl YXAgc2VnbWVudCwKLQkgKiB0aGVuIGVuZm9yY2UgdGhhdCB0aGUgc2l6ZSBvZiBhdmFpbGFibGUg dm1lbSBmb3IgdGhpcyBhcmVhIHJlbWFpbnMKLQkgKiBhYm92ZSBhYm91dCAxLzMybmQgZnJlZS4K LQkgKi8KLQlpZiAodHlwZSA9PSBBUkNfQlVGQ19EQVRBICYmIHppb19hcmVuYSAhPSBOVUxMICYm Ci0JICAgIHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fRlJFRSkgPAotCSAgICAodm1lbV9zaXpl KHppb19hcmVuYSwgVk1FTV9BTExPQykgPj4gNSkpCi0JCXJldHVybiAoMSk7Ci0jZW5kaWYKLSNl bmRpZgkvKiBzdW4gKi8KLQogCWlmIChhcmNfcmVjbGFpbV9uZWVkZWQoKSkKIAkJcmV0dXJuICgx KTsKIApAQCAtMzk0NiwyMCArMzk1NiwxNiBAQCBzdGF0aWMgaW50CiBhcmNfbWVtb3J5X3Rocm90 dGxlKHVpbnQ2NF90IHJlc2VydmUsIHVpbnQ2NF90IHR4ZykKIHsKICNpZmRlZiBfS0VSTkVMCi0J dWludDY0X3QgYXZhaWxhYmxlX21lbW9yeSA9Ci0JICAgIHB0b2EoKHVpbnRtYXhfdCl2bV9jbnQu dl9mcmVlX2NvdW50ICsgdm1fY250LnZfY2FjaGVfY291bnQpOworCXVpbnQ2NF90IGF2YWlsYWJs ZV9tZW1vcnkgPSBwdG9iKGZyZWVtZW0pOwogCXN0YXRpYyB1aW50NjRfdCBwYWdlX2xvYWQgPSAw OwogCXN0YXRpYyB1aW50NjRfdCBsYXN0X3R4ZyA9IDA7CiAKLSNpZmRlZiBzdW4KLSNpZiBkZWZp bmVkKF9faTM4NikKKyNpZiBkZWZpbmVkKF9faTM4NikgfHwgIWRlZmluZWQoVU1BX01EX1NNQUxM X0FMTE9DKQogCWF2YWlsYWJsZV9tZW1vcnkgPQotCSAgICBNSU4oYXZhaWxhYmxlX21lbW9yeSwg dm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkpOworCSAgICBNSU4oYXZhaWxhYmxlX21l bW9yeSwgcHRvYih2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSkpOwogI2VuZGlmCi0j ZW5kaWYJLyogc3VuICovCiAKLQlpZiAodm1fY250LnZfZnJlZV9jb3VudCArIHZtX2NudC52X2Nh Y2hlX2NvdW50ID4KLQkgICAgKHVpbnQ2NF90KXBoeXNtZW0gKiBhcmNfbG90c2ZyZWVfcGVyY2Vu dCAvIDEwMCkKKwlpZiAoZnJlZW1lbSA+ICh1aW50NjRfdClwaHlzbWVtICogYXJjX2xvdHNmcmVl X3BlcmNlbnQgLyAxMDApCiAJCXJldHVybiAoMCk7CiAKIAlpZiAodHhnID4gbGFzdF90eGcpIHsK QEAgLTM5NzIsNyArMzk3OCw3IEBAIGFyY19tZW1vcnlfdGhyb3R0bGUodWludDY0X3QgcmVzZXJ2 ZSwgdWludDY0X3QgdHhnCiAJICogY29udGludWUgdG8gbGV0IHBhZ2Ugd3JpdGVzIG9jY3VyIGFz IHF1aWNrbHkgYXMgcG9zc2libGUuCiAJICovCiAJaWYgKGN1cnByb2MgPT0gcGFnZXByb2MpIHsK LQkJaWYgKHBhZ2VfbG9hZCA+IGF2YWlsYWJsZV9tZW1vcnkgLyA0KQorCQlpZiAocGFnZV9sb2Fk ID4gTUFYKHB0b2IobWluZnJlZSksIGF2YWlsYWJsZV9tZW1vcnkpIC8gNCkKIAkJCXJldHVybiAo U0VUX0VSUk9SKEVSRVNUQVJUKSk7CiAJCS8qIE5vdGU6IHJlc2VydmUgaXMgaW5mbGF0ZWQsIHNv IHdlIGRlZmxhdGUgKi8KIAkJcGFnZV9sb2FkICs9IHJlc2VydmUgLyA4Owo= 146946 2014-09-06 16:38:13 +0000 2014-09-08 15:25:11 +0000 arc reclaim refactor (against stable/10) arc-reclaim-10.patch text/plain 11359 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MTExNikKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTMzLDEzICsx MzMsNiBAQCBrbWVtX3NpemUodm9pZCkKIAlyZXR1cm4gKGttZW1fc2l6ZV92YWwpOwogfQogCi11 aW50NjRfdAota21lbV91c2VkKHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtZW1fc2l6ZShrbWVtX2Fy ZW5hLCBWTUVNX0FMTE9DKSk7Ci19Ci0KIHN0YXRpYyBpbnQKIGttZW1fc3RkX2NvbnN0cnVjdG9y KHZvaWQgKm1lbSwgaW50IHNpemUgX191bnVzZWQsIHZvaWQgKnByaXZhdGUsIGludCBmbGFncykK IHsKSW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCShyZXZpc2lvbiAy NzExMTYpCisrKyBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMvc3lzL2ttZW0uaAkod29ya2lu ZyBjb3B5KQpAQCAtNjYsNyArNjYsNiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZv aWQgKnpmc19rbWVtX2FsbG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19r bWVtX2ZyZWUodm9pZCAqYnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9p ZCk7Ci11aW50NjRfdCBrbWVtX3VzZWQodm9pZCk7CiBrbWVtX2NhY2hlX3QgKmttZW1fY2FjaGVf Y3JlYXRlKGNoYXIgKm5hbWUsIHNpemVfdCBidWZzaXplLCBzaXplX3QgYWxpZ24sCiAgICAgaW50 ICgqY29uc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqLCBpbnQpLCB2b2lkICgqZGVzdHJ1Y3Rvciko dm9pZCAqLCB2b2lkICopLAogICAgIHZvaWQgKCpyZWNsYWltKSh2b2lkICopIF9fdW51c2VkLCB2 b2lkICpwcml2YXRlLCB2bWVtX3QgKnZtcCwgaW50IGNmbGFncyk7CkBAIC03OCw2ICs3Nyw5IEBA IHZvaWQga21lbV9yZWFwKHZvaWQpOwogaW50IGttZW1fZGVidWdnaW5nKHZvaWQpOwogdm9pZCAq Y2FsbG9jKHNpemVfdCBuLCBzaXplX3Qgcyk7CiAKKyNkZWZpbmUJZnJlZW1lbQkJCQkoY250LnZf ZnJlZV9jb3VudCArIGNudC52X2NhY2hlX2NvdW50KQorI2RlZmluZQltaW5mcmVlCQkJCWNudC52 X2ZyZWVfbWluCisjZGVmaW5lCWhlYXBfYXJlbmEJCQlrbWVtX2FyZW5hCiAjZGVmaW5lCWttZW1f YWxsb2Moc2l6ZSwga21mbGFncykJemZzX2ttZW1fYWxsb2MoKHNpemUpLCAoa21mbGFncykpCiAj ZGVmaW5lCWttZW1femFsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChzaXplKSwg KGttZmxhZ3MpIHwgTV9aRVJPKQogI2RlZmluZQlrbWVtX2ZyZWUoYnVmLCBzaXplKQkJemZzX2tt ZW1fZnJlZSgoYnVmKSwgKHNpemUpKQpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJp cy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmli L29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzExMTYpCisr KyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3 b3JraW5nIGNvcHkpCkBAIC0xOTMsOSArMTkzLDYgQEAgZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hf ZGlzYWJsZTsKICAqLwogc3RhdGljIGJvb2xlYW5fdCBhcmNfd2FybTsKIAotLyoKLSAqIFRoZXNl IHR1bmFibGVzIGFyZSBmb3IgcGVyZm9ybWFuY2UgYW5hbHlzaXMuCi0gKi8KIHVpbnQ2NF90IHpm c19hcmNfbWF4OwogdWludDY0X3QgemZzX2FyY19taW47CiB1aW50NjRfdCB6ZnNfYXJjX21ldGFf bGltaXQgPSAwOwpAQCAtMjA0LDcgKzIwMSwyMSBAQCBpbnQgemZzX2FyY19zaHJpbmtfc2hpZnQg PSAwOwogaW50IHpmc19hcmNfcF9taW5fc2hpZnQgPSAwOwogaW50IHpmc19kaXNhYmxlX2R1cF9l dmljdGlvbiA9IDA7CiB1aW50NjRfdCB6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEw MjQ7IC8qIDhLQiAqLwordV9pbnQgemZzX2FyY19mcmVlX3RhcmdldCA9ICgxIDw8IDE2KTsgLyog ZGVmYXVsdCBiZWZvcmUgcGFnZWRhZW1vbiBpbml0IG9ubHkgKi8KK2ludCB6ZnNfYXJjX3JlY2xh aW1fY2FjaGVfZnJlZSA9IDE7CiAKK3N0YXRpYyBpbnQgc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVf dGFyZ2V0KFNZU0NUTF9IQU5ETEVSX0FSR1MpOworCisjaWZkZWYgX0tFUk5FTAorc3RhdGljIHZv aWQKK2FyY19mcmVlX3RhcmdldF9pbml0KHZvaWQgKnVudXNlZCBfX3VudXNlZCkKK3sKKworCXpm c19hcmNfZnJlZV90YXJnZXQgPSB2bV9wYWdlb3V0X3dha2V1cF90aHJlc2g7Cit9CitTWVNJTklU KGFyY19mcmVlX3RhcmdldF9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9BTlks CisgICAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIE5VTEwpOworCiBUVU5BQkxFX1FVQUQoInZmcy56 ZnMuYXJjX21heCIsICZ6ZnNfYXJjX21heCk7CiBUVU5BQkxFX1FVQUQoInZmcy56ZnMuYXJjX21p biIsICZ6ZnNfYXJjX21pbik7CiBUVU5BQkxFX1FVQUQoInZmcy56ZnMuYXJjX21ldGFfbGltaXQi LCAmemZzX2FyY19tZXRhX2xpbWl0KTsKQEAgLTIxNyw3ICsyMjgsNDAgQEAgU1lTQ1RMX1VRVUFE KF92ZnNfemZzLCBPSURfQVVUTywgYXJjX21pbiwgQ1RMRkxBR18KIFNZU0NUTF9VUVVBRChfdmZz X3pmcywgT0lEX0FVVE8sIGFyY19hdmVyYWdlX2Jsb2Nrc2l6ZSwgQ1RMRkxBR19SRFRVTiwKICAg ICAmemZzX2FyY19hdmVyYWdlX2Jsb2Nrc2l6ZSwgMCwKICAgICAiQVJDIGF2ZXJhZ2UgYmxvY2tz aXplIik7CitTWVNDVExfSU5UKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX3JlY2xhaW1fY2FjaGVf ZnJlZSwgQ1RMRkxBR19SV1RVTiwKKyAgICAmemZzX2FyY19yZWNsYWltX2NhY2hlX2ZyZWUsIDAs CisgICAgIkFSQyB0cmVhdHMgY2FjaGVkIHBhZ2VzIGFzIGZyZWUgYmxvY2tzaXplIik7CisvKgor ICogV2UgZG9uJ3QgaGF2ZSBhIHR1bmFibGUgZm9yIGFyY19mcmVlX3RhcmdldCBkdWUgdG8gdGhl IGRlcGVuZGVuY3kgb24KKyAqIHBhZ2VkYWVtb24gaW5pdGlhbGlzYXRpb24uCisgKi8KK1NZU0NU TF9QUk9DKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2ZyZWVfdGFyZ2V0LAorICAgIENUTFRZUEVf VUlOVCB8IENUTEZMQUdfTVBTQUZFIHwgQ1RMRkxBR19SVywgMCwgc2l6ZW9mKHVfaW50KSwKKyAg ICBzeXNjdGxfdmZzX3pmc19hcmNfZnJlZV90YXJnZXQsICJJVSIsCisgICAgIkRlc2lyZWQgbnVt YmVyIG9mIGZyZWUgcGFnZXMgYmVsb3cgd2hpY2ggQVJDIHRyaWdnZXJzIHJlY2xhaW0iKTsKIAor c3RhdGljIGludAorc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0KFNZU0NUTF9IQU5ETEVS X0FSR1MpCit7CisJdV9pbnQgdmFsOworCWludCBlcnI7CisKKwl2YWwgPSB6ZnNfYXJjX2ZyZWVf dGFyZ2V0OworCWVyciA9IHN5c2N0bF9oYW5kbGVfaW50KG9pZHAsICZ2YWwsIDAsIHJlcSk7CisJ aWYgKGVyciAhPSAwIHx8IHJlcS0+bmV3cHRyID09IE5VTEwpCisJCXJldHVybiAoZXJyKTsKKwor CWlmICh2YWwgPCBtaW5mcmVlKQorCQlyZXR1cm4gKEVJTlZBTCk7CisJaWYgKHZhbCA+IGNudC52 X3BhZ2VfY291bnQpCisJCXJldHVybiAoRUlOVkFMKTsKKworCXpmc19hcmNfZnJlZV90YXJnZXQg PSB2YWw7CisKKwlyZXR1cm4gKDApOworfQorI2VuZGlmCisKIC8qCiAgKiBOb3RlIHRoYXQgYnVm ZmVycyBjYW4gYmUgaW4gb25lIG9mIDYgc3RhdGVzOgogICoJQVJDX2Fub24JLSBhbm9ueW1vdXMg KGRpc2N1c3NlZCBiZWxvdykKQEAgLTI0MjEsOSArMjQ2NSwxMiBAQCBhcmNfZmx1c2goc3BhX3Qg KnNwYSkKIHZvaWQKIGFyY19zaHJpbmsodm9pZCkKIHsKKwogCWlmIChhcmNfYyA+IGFyY19jX21p bikgewogCQl1aW50NjRfdCB0b19mcmVlOwogCisJCURUUkFDRV9QUk9CRTIoYXJjX19zaHJpbmss IHVpbnQ2NF90LCBhcmNfYywgdWludDY0X3QsCisJCQlhcmNfY19taW4pOwogI2lmZGVmIF9LRVJO RUwKIAkJdG9fZnJlZSA9IGFyY19jID4+IGFyY19zaHJpbmtfc2hpZnQ7CiAjZWxzZQpAQCAtMjQ0 Myw4ICsyNDkwLDExIEBAIGFyY19zaHJpbmsodm9pZCkKIAkJQVNTRVJUKChpbnQ2NF90KWFyY19w ID49IDApOwogCX0KIAotCWlmIChhcmNfc2l6ZSA+IGFyY19jKQorCWlmIChhcmNfc2l6ZSA+IGFy Y19jKSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19zaHJpbmtfYWRqdXN0LCB1aW50NjRfdCwgYXJj X3NpemUsCisJCQl1aW50NjRfdCwgYXJjX2MpOwogCQlhcmNfYWRqdXN0KCk7CisJfQogfQogCiBz dGF0aWMgaW50IG5lZWRmcmVlID0gMDsKQEAgLTI0NTIsMTggKzI1MDIsMzAgQEAgc3RhdGljIGlu dCBuZWVkZnJlZSA9IDA7CiBzdGF0aWMgaW50CiBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIHsK Kwl1X2ludCBmbTsKIAogI2lmZGVmIF9LRVJORUwKIAotCWlmIChuZWVkZnJlZSkKKwlpZiAobmVl ZGZyZWUpIHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9uZWVkZnJlZSk7CiAJCXJldHVy biAoMSk7CisJfQogCiAJLyoKIAkgKiBDb29wZXJhdGUgd2l0aCBwYWdlZGFlbW9uIHdoZW4gaXQn cyB0aW1lIGZvciBpdCB0byBzY2FuCiAJICogYW5kIHJlY2xhaW0gc29tZSBwYWdlcy4KIAkgKi8K LQlpZiAodm1fcGFnaW5nX25lZWRlZCgpKQorCWlmICh6ZnNfYXJjX3JlY2xhaW1fY2FjaGVfZnJl ZSA9PSAwKQorCQlmbSA9IGNudC52X2ZyZWVfY291bnQ7CisJZWxzZQorCQlmbSA9IGZyZWVtZW07 CisKKwlpZiAoZm0gPCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KSB7CisJCURUUkFDRV9QUk9CRTMoYXJj X19yZWNsYWltX2ZyZWVtZW0sIHVpbnQ2NF90LAorCQkgICAgZm0sIHVpbnQ2NF90LCB6ZnNfYXJj X2ZyZWVfdGFyZ2V0LAorCQkgICAgaW50LCB6ZnNfYXJjX3JlY2xhaW1fY2FjaGVfZnJlZSk7CiAJ CXJldHVybiAoMSk7CisJfQogCiAjaWZkZWYgc3VuCiAJLyoKQEAgLTI0OTEsOCArMjU1MywxOSBA QCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIAlpZiAoYXZhaWxybWVtIDwgc3dhcGZzX21pbmZy ZWUgKyBzd2FwZnNfcmVzZXJ2ZSArIGV4dHJhKQogCQlyZXR1cm4gKDEpOwogCi0jaWYgZGVmaW5l ZChfX2kzODYpCiAJLyoKKwkgKiBDaGVjayB0aGF0IHdlIGhhdmUgZW5vdWdoIGF2YWlscm1lbSB0 aGF0IG1lbW9yeSBsb2NraW5nIChlLmcuLCB2aWEKKwkgKiBtbG9jaygzQykgb3IgbWVtY250bCgy KSkgY2FuIHN0aWxsIHN1Y2NlZWQuICAocGFnZXNfcHBfbWF4aW11bQorCSAqIHN0b3JlcyB0aGUg bnVtYmVyIG9mIHBhZ2VzIHRoYXQgY2Fubm90IGJlIGxvY2tlZDsgd2hlbiBhdmFpbHJtZW0KKwkg KiBkcm9wcyBiZWxvdyBwYWdlc19wcF9tYXhpbXVtLCBwYWdlIGxvY2tpbmcgbWVjaGFuaXNtcyBz dWNoIGFzCisJICogcGFnZV9wcF9sb2NrKCkgd2lsbCBmYWlsLikKKwkgKi8KKwlpZiAoYXZhaWxy bWVtIDw9IHBhZ2VzX3BwX21heGltdW0pCisJCXJldHVybiAoMSk7CisKKyNlbmRpZgkvKiBzdW4g Ki8KKyNpZiBkZWZpbmVkKF9faTM4NikgfHwgIWRlZmluZWQoVU1BX01EX1NNQUxMX0FMTE9DKQor CS8qCiAJICogSWYgd2UncmUgb24gYW4gaTM4NiBwbGF0Zm9ybSwgaXQncyBwb3NzaWJsZSB0aGF0 IHdlJ2xsIGV4aGF1c3QgdGhlCiAJICoga2VybmVsIGhlYXAgc3BhY2UgYmVmb3JlIHdlIGV2ZXIg cnVuIG91dCBvZiBhdmFpbGFibGUgcGh5c2ljYWwKIAkgKiBtZW1vcnkuICBNb3N0IGNoZWNrcyBv ZiB0aGUgc2l6ZSBvZiB0aGUgaGVhcF9hcmVhIGNvbXBhcmUgYWdhaW5zdApAQCAtMjUwMywxOSAr MjU3NiwzNSBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIAkgKiBoZWFwIGlzIGFsbG9jYXRl ZC4gIChPciwgaW4gdGhlIGNhbGN1bGF0aW9uLCBpZiBsZXNzIHRoYW4gMS80dGggaXMKIAkgKiBm cmVlKQogCSAqLwotCWlmIChidG9wKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpKSA8 Ci0JICAgIChidG9wKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUgfCBWTUVNX0FMTE9D KSkgPj4gMikpCisJaWYgKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpIDwKKwkgICAg KHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUgfCBWTUVNX0FMTE9DKSA+PiAyKSkgewor CQlEVFJBQ0VfUFJPQkUyKGFyY19fcmVjbGFpbV91c2VkLCB1aW50NjRfdCwKKwkJICAgIHZtZW1f c2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpLCB1aW50NjRfdCwKKwkJICAgICh2bWVtX3NpemUo aGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwgVk1FTV9BTExPQykpID4+IDIpOwogCQlyZXR1cm4gKDEp OworCX0KICNlbmRpZgotI2Vsc2UJLyogIXN1biAqLwotCWlmIChrbWVtX3VzZWQoKSA+IChrbWVt X3NpemUoKSAqIDMpIC8gNCkKKyNpZmRlZiBzdW4KKwkvKgorCSAqIElmIHppbyBkYXRhIHBhZ2Vz IGFyZSBiZWluZyBhbGxvY2F0ZWQgb3V0IG9mIGEgc2VwYXJhdGUgaGVhcCBzZWdtZW50LAorCSAq IHRoZW4gZW5mb3JjZSB0aGF0IHRoZSBzaXplIG9mIGF2YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFy ZW5hIHJlbWFpbnMKKwkgKiBhYm92ZSBhYm91dCAxLzE2dGggZnJlZS4KKwkgKgorCSAqIE5vdGU6 IFRoZSAxLzE2dGggYXJlbmEgZnJlZSByZXF1aXJlbWVudCB3YXMgcHV0IGluIHBsYWNlCisJICog dG8gYWdncmVzc2l2ZWx5IGV2aWN0IG1lbW9yeSBmcm9tIHRoZSBhcmMgaW4gb3JkZXIgdG8gYXZv aWQKKwkgKiBtZW1vcnkgZnJhZ21lbnRhdGlvbiBpc3N1ZXMuCisJICovCisJaWYgKHppb19hcmVu YSAhPSBOVUxMICYmCisJICAgIHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fRlJFRSkgPAorCSAg ICAodm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9BTExPQykgPj4gNCkpCiAJCXJldHVybiAoMSk7 CiAjZW5kaWYJLyogc3VuICovCi0KLSNlbHNlCisjZWxzZQkvKiBfS0VSTkVMICovCiAJaWYgKHNw YV9nZXRfcmFuZG9tKDEwMCkgPT0gMCkKIAkJcmV0dXJuICgxKTsKLSNlbmRpZgorI2VuZGlmCS8q IF9LRVJORUwgKi8KKwlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX25vKTsKKwogCXJldHVybiAo MCk7CiB9CiAKQEAgLTI1MjksNiArMjYxOCw3IEBAIGFyY19rbWVtX3JlYXBfbm93KGFyY19yZWNs YWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJa21lbV9jYWNoZV90CQkqcHJldl9jYWNoZSA9IE5VTEw7 CiAJa21lbV9jYWNoZV90CQkqcHJldl9kYXRhX2NhY2hlID0gTlVMTDsKIAorCURUUkFDRV9QUk9C RShhcmNfX2ttZW1fcmVhcF9zdGFydCk7CiAjaWZkZWYgX0tFUk5FTAogCWlmIChhcmNfbWV0YV91 c2VkID49IGFyY19tZXRhX2xpbWl0KSB7CiAJCS8qCkBAIC0yNTY0LDYgKzI2NTQsMTYgQEAgYXJj X2ttZW1fcmVhcF9ub3coYXJjX3JlY2xhaW1fc3RyYXRlZ3lfdCBzdHJhdCkKIAl9CiAJa21lbV9j YWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOwogCWttZW1fY2FjaGVfcmVhcF9ub3coaGRyX2NhY2hl KTsKKworI2lmZGVmIHN1bgorCS8qCisJICogQXNrIHRoZSB2bWVtIGFyZWFuYSB0byByZWNsYWlt IHVudXNlZCBtZW1vcnkgZnJvbSBpdHMKKwkgKiBxdWFudHVtIGNhY2hlcy4KKwkgKi8KKwlpZiAo emlvX2FyZW5hICE9IE5VTEwgJiYgc3RyYXQgPT0gQVJDX1JFQ0xBSU1fQUdHUikKKwkJdm1lbV9x Y2FjaGVfcmVhcCh6aW9fYXJlbmEpOworI2VuZGlmCisJRFRSQUNFX1BST0JFKGFyY19fa21lbV9y ZWFwX2VuZCk7CiB9CiAKIHN0YXRpYyB2b2lkCkBAIC0yNzEzLDIwICsyODEzLDYgQEAgYXJjX2V2 aWN0X25lZWRlZChhcmNfYnVmX2NvbnRlbnRzX3QgdHlwZSkKIAlpZiAodHlwZSA9PSBBUkNfQlVG Q19NRVRBREFUQSAmJiBhcmNfbWV0YV91c2VkID49IGFyY19tZXRhX2xpbWl0KQogCQlyZXR1cm4g KDEpOwogCi0jaWZkZWYgc3VuCi0jaWZkZWYgX0tFUk5FTAotCS8qCi0JICogSWYgemlvIGRhdGEg cGFnZXMgYXJlIGJlaW5nIGFsbG9jYXRlZCBvdXQgb2YgYSBzZXBhcmF0ZSBoZWFwIHNlZ21lbnQs Ci0JICogdGhlbiBlbmZvcmNlIHRoYXQgdGhlIHNpemUgb2YgYXZhaWxhYmxlIHZtZW0gZm9yIHRo aXMgYXJlYSByZW1haW5zCi0JICogYWJvdmUgYWJvdXQgMS8zMm5kIGZyZWUuCi0JICovCi0JaWYg KHR5cGUgPT0gQVJDX0JVRkNfREFUQSAmJiB6aW9fYXJlbmEgIT0gTlVMTCAmJgotCSAgICB2bWVt X3NpemUoemlvX2FyZW5hLCBWTUVNX0ZSRUUpIDwKLQkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEs IFZNRU1fQUxMT0MpID4+IDUpKQotCQlyZXR1cm4gKDEpOwotI2VuZGlmCi0jZW5kaWYJLyogc3Vu ICovCi0KIAlpZiAoYXJjX3JlY2xhaW1fbmVlZGVkKCkpCiAJCXJldHVybiAoMSk7CiAKQEAgLTM4 ODUsMjAgKzM5NzEsMTYgQEAgc3RhdGljIGludAogYXJjX21lbW9yeV90aHJvdHRsZSh1aW50NjRf dCByZXNlcnZlLCB1aW50NjRfdCB0eGcpCiB7CiAjaWZkZWYgX0tFUk5FTAotCXVpbnQ2NF90IGF2 YWlsYWJsZV9tZW1vcnkgPQotCSAgICBwdG9hKCh1aW50bWF4X3QpY250LnZfZnJlZV9jb3VudCAr IGNudC52X2NhY2hlX2NvdW50KTsKKwl1aW50NjRfdCBhdmFpbGFibGVfbWVtb3J5ID0gcHRvYihm cmVlbWVtKTsKIAlzdGF0aWMgdWludDY0X3QgcGFnZV9sb2FkID0gMDsKIAlzdGF0aWMgdWludDY0 X3QgbGFzdF90eGcgPSAwOwogCi0jaWZkZWYgc3VuCi0jaWYgZGVmaW5lZChfX2kzODYpCisjaWYg ZGVmaW5lZChfX2kzODYpIHx8ICFkZWZpbmVkKFVNQV9NRF9TTUFMTF9BTExPQykKIAlhdmFpbGFi bGVfbWVtb3J5ID0KLQkgICAgTUlOKGF2YWlsYWJsZV9tZW1vcnksIHZtZW1fc2l6ZShoZWFwX2Fy ZW5hLCBWTUVNX0ZSRUUpKTsKKwkgICAgTUlOKGF2YWlsYWJsZV9tZW1vcnksIHB0b2Iodm1lbV9z aXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkpKTsKICNlbmRpZgotI2VuZGlmCS8qIHN1biAqLwog Ci0JaWYgKGNudC52X2ZyZWVfY291bnQgKyBjbnQudl9jYWNoZV9jb3VudCA+Ci0JICAgICh1aW50 NjRfdClwaHlzbWVtICogYXJjX2xvdHNmcmVlX3BlcmNlbnQgLyAxMDApCisJaWYgKGZyZWVtZW0g PiAodWludDY0X3QpcGh5c21lbSAqIGFyY19sb3RzZnJlZV9wZXJjZW50IC8gMTAwKQogCQlyZXR1 cm4gKDApOwogCiAJaWYgKHR4ZyA+IGxhc3RfdHhnKSB7CkBAIC0zOTExLDcgKzM5OTMsNyBAQCBh cmNfbWVtb3J5X3Rocm90dGxlKHVpbnQ2NF90IHJlc2VydmUsIHVpbnQ2NF90IHR4ZwogCSAqIGNv bnRpbnVlIHRvIGxldCBwYWdlIHdyaXRlcyBvY2N1ciBhcyBxdWlja2x5IGFzIHBvc3NpYmxlLgog CSAqLwogCWlmIChjdXJwcm9jID09IHBhZ2Vwcm9jKSB7Ci0JCWlmIChwYWdlX2xvYWQgPiBhdmFp bGFibGVfbWVtb3J5IC8gNCkKKwkJaWYgKHBhZ2VfbG9hZCA+IE1BWChwdG9iKG1pbmZyZWUpLCBh dmFpbGFibGVfbWVtb3J5KSAvIDQpCiAJCQlyZXR1cm4gKFNFVF9FUlJPUihFUkVTVEFSVCkpOwog CQkvKiBOb3RlOiByZXNlcnZlIGlzIGluZmxhdGVkLCBzbyB3ZSBkZWZsYXRlICovCiAJCXBhZ2Vf bG9hZCArPSByZXNlcnZlIC8gODsKSW5kZXg6IHN5cy92bS92bV9wYWdlb3V0LmMKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkocmV2aXNpb24gMjcxMTE2KQorKysgc3lzL3ZtL3Zt X3BhZ2VvdXQuYwkod29ya2luZyBjb3B5KQpAQCAtMTE1LDEwICsxMTUsMTQgQEAgX19GQlNESUQo IiRGcmVlQlNEJCIpOwogCiAvKiB0aGUga2VybmVsIHByb2Nlc3MgInZtX3BhZ2VvdXQiKi8KIHN0 YXRpYyB2b2lkIHZtX3BhZ2VvdXQodm9pZCk7CitzdGF0aWMgdm9pZCB2bV9wYWdlb3V0X2luaXQo dm9pZCk7CiBzdGF0aWMgaW50IHZtX3BhZ2VvdXRfY2xlYW4odm1fcGFnZV90KTsKIHN0YXRpYyB2 b2lkIHZtX3BhZ2VvdXRfc2NhbihzdHJ1Y3Qgdm1fZG9tYWluICp2bWQsIGludCBwYXNzKTsKIHN0 YXRpYyB2b2lkIHZtX3BhZ2VvdXRfbWlnaHRiZV9vb20oc3RydWN0IHZtX2RvbWFpbiAqdm1kLCBp bnQgcGFzcyk7CiAKK1NZU0lOSVQocGFnZWRhZW1vbl9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdF LCBTSV9PUkRFUl9GSVJTVCwgdm1fcGFnZW91dF9pbml0LAorICAgIE5VTEwpOworCiBzdHJ1Y3Qg cHJvYyAqcGFnZXByb2M7CiAKIHN0YXRpYyBzdHJ1Y3Qga3Byb2NfZGVzYyBwYWdlX2twID0gewpA QCAtMTI2LDcgKzEzMCw3IEBAIHN0YXRpYyBzdHJ1Y3Qga3Byb2NfZGVzYyBwYWdlX2twID0gewog CXZtX3BhZ2VvdXQsCiAJJnBhZ2Vwcm9jCiB9OwotU1lTSU5JVChwYWdlZGFlbW9uLCBTSV9TVUJf S1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9GSVJTVCwga3Byb2Nfc3RhcnQsCitTWVNJTklUKHBhZ2Vk YWVtb24sIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX1NFQ09ORCwga3Byb2Nfc3RhcnQs CiAgICAgJnBhZ2Vfa3ApOwogCiAjaWYgIWRlZmluZWQoTk9fU1dBUFBJTkcpCkBAIC0xNjUwLDE1 ICsxNjU0LDExIEBAIHZtX3BhZ2VvdXRfd29ya2VyKHZvaWQgKmFyZykKIH0KIAogLyoKLSAqCXZt X3BhZ2VvdXQgaXMgdGhlIGhpZ2ggbGV2ZWwgcGFnZW91dCBkYWVtb24uCisgKgl2bV9wYWdlb3V0 X2luaXQgaW5pdGlhbGlzZXMgYmFzaWMgcGFnZW91dCBkYWVtb24gc2V0dGluZ3MuCiAgKi8KIHN0 YXRpYyB2b2lkCi12bV9wYWdlb3V0KHZvaWQpCit2bV9wYWdlb3V0X2luaXQodm9pZCkKIHsKLSNp ZiBNQVhNRU1ET00gPiAxCi0JaW50IGVycm9yLCBpOwotI2VuZGlmCi0KIAkvKgogCSAqIEluaXRp YWxpemUgc29tZSBwYWdpbmcgcGFyYW1ldGVycy4KIAkgKi8KQEAgLTE3MDQsNyArMTcwNCwxOCBA QCBzdGF0aWMgdm9pZAogCS8qIFhYWCBkb2VzIG5vdCByZWFsbHkgYmVsb25nIGhlcmUgKi8KIAlp ZiAodm1fcGFnZV9tYXhfd2lyZWQgPT0gMCkKIAkJdm1fcGFnZV9tYXhfd2lyZWQgPSBjbnQudl9m cmVlX2NvdW50IC8gMzsKK30KIAorLyoKKyAqICAgICB2bV9wYWdlb3V0IGlzIHRoZSBoaWdoIGxl dmVsIHBhZ2VvdXQgZGFlbW9uLgorICovCitzdGF0aWMgdm9pZAordm1fcGFnZW91dCh2b2lkKQor eworI2lmIE1BWE1FTURPTSA+IDEKKwlpbnQgZXJyb3IsIGk7CisjZW5kaWYKKwogCXN3YXBfcGFn ZXJfc3dhcF9pbml0KCk7CiAjaWYgTUFYTUVNRE9NID4gMQogCWZvciAoaSA9IDE7IGkgPCB2bV9u ZG9tYWluczsgaSsrKSB7Cg== 146947 2014-09-06 16:38:59 +0000 2014-09-06 16:38:59 +0000 ARC evict dtrace script arc-evict.d text/plain 318 smh IyEvdXNyL3NiaW4vZHRyYWNlIC1zCgojcHJhZ21hIEQgb3B0aW9uIHF1aWV0CgpkdHJhY2U6OjpC RUdJTgp7CiAgICAgICAgdHJhY2UoIlRyYWNpbmcgQVJDIGV2aWN0cy4uLlxuIik7Cn0KCmZidDo6 YXJjX2V2aWN0OmVudHJ5Ci9hcmczID09IDAvCnsKICAgICAgICBwcmludGYoIiVZICUtMTBhICUt MTBzICUtMTBzICVkIGJ5dGVzXG4iLCB3YWxsdGltZXN0YW1wLCBhcmdzWzBdLAogICAgICAgICAg ICBhcmc0ID09IDAgPyAiZGF0YSIgOiAibWV0YWRhdGEiLAogICAgICAgICAgICBhcmczID09IDAg PyAiZXZpY3QiIDogInJlY3ljbGUiLCAgYXJnMik7Cn0K 146948 2014-09-06 16:39:27 +0000 2014-09-06 16:39:27 +0000 ARC reap dtrace script arc-reap.d text/plain 399 smh IyEvdXNyL3NiaW4vZHRyYWNlIC1zCgpmYnQ6OmFyY19rbWVtX3JlYXBfbm93OmVudHJ5LApmYnQ6 OmFyY19hZGp1c3Q6ZW50cnkKewogICAgICAgIHNlbGYtPnN0YXJ0W3Byb2JlZnVuY10gPSB0aW1l c3RhbXA7Cn0KCmZidDo6YXJjX3NocmluazplbnRyeQp7CiAgICAgICAgdHJhY2UoImNhbGxlZCIp Owp9CgpmYnQ6OmFyY19rbWVtX3JlYXBfbm93OnJldHVybiwKZmJ0OjphcmNfYWRqdXN0OnJldHVy bgovc2VsZi0+c3RhcnRbcHJvYmVmdW5jXS8KewogICAgICAgIHByaW50ZigiJVkgJWQgbXMiLCB3 YWxsdGltZXN0YW1wLAogICAgICAgICAgICAodGltZXN0YW1wIC0gc2VsZi0+c3RhcnRbcHJvYmVm dW5jXSkgLyAxMDAwMDAwKTsKICAgICAgICBzZWxmLT5zdGFydFtwcm9iZWZ1bmNdID0gMDsKfQoK 146949 2014-09-06 16:39:53 +0000 2014-09-06 16:39:53 +0000 ARC reclaim dtrace script arc-reclaim.d text/plain 392 smh IyEvdXNyL3NiaW4vZHRyYWNlIC1zCgovKgpmYnQ6OnZtX3BhZ2VvdXRfZ3Jvd19jYWNoZTplbnRy eQovYXJnMCA+IDAvCnsKICAgICAgICBwcmludGYoIiVZIiwgd2FsbHRpbWVzdGFtcCkKfQoKZmJ0 Ojp2bV9wYWdlb3V0X3NjYW46ZW50cnkKL2FyZzAgPiAxLwp7CiAgICAgICAgcHJpbnRmKCIlWSIs IHdhbGx0aW1lc3RhbXApCn0KKi8KCnZtOjo6dm0tbG93bWVtX2NhY2hlLAp2bTo6OnZtLWxvd21l bV9zY2FuLApzZHQ6OjphcmMtcmVjbGFpbV9uZWVkZnJlZQp7CiAgICAgICAgcHJpbnRmKCIlWSIs IHdhbGx0aW1lc3RhbXApCn0KCnNkdDo6OmFyYy1yZWNsYWltX2ZyZWVtZW0KewogICAgICAgIHBy aW50ZigiJVkgJWxkIDwgJWxkIiwgd2FsbHRpbWVzdGFtcCwgYXJnMCwgYXJnMSkKfQo= 147014 2014-09-07 15:50:26 +0000 2014-09-08 15:25:11 +0000 VM lowmem probe lowmem_probe.patch text/plain 1701 smh SW5kZXg6IHN5cy92bS92bV9wYWdlb3V0LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL3ZtL3ZtX3BhZ2Vv dXQuYwkocmV2aXNpb24gMjcxMTU2KQorKysgc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkod29ya2luZyBj b3B5KQpAQCAtNzYsNiArNzYsNyBAQAogX19GQlNESUQoIiRGcmVlQlNEJCIpOwogCiAjaW5jbHVk ZSAib3B0X3ZtLmgiCisjaW5jbHVkZSAib3B0X2tkdHJhY2UuaCIKICNpbmNsdWRlIDxzeXMvcGFy YW0uaD4KICNpbmNsdWRlIDxzeXMvc3lzdG0uaD4KICNpbmNsdWRlIDxzeXMva2VybmVsLmg+CkBA IC04OSw2ICs5MCw3IEBAIF9fRkJTRElEKCIkRnJlZUJTRCQiKTsKICNpbmNsdWRlIDxzeXMvcmFj Y3QuaD4KICNpbmNsdWRlIDxzeXMvcmVzb3VyY2V2YXIuaD4KICNpbmNsdWRlIDxzeXMvc2NoZWQu aD4KKyNpbmNsdWRlIDxzeXMvc2R0Lmg+CiAjaW5jbHVkZSA8c3lzL3NpZ25hbHZhci5oPgogI2lu Y2x1ZGUgPHN5cy9zbXAuaD4KICNpbmNsdWRlIDxzeXMvdm5vZGUuaD4KQEAgLTEzMyw2ICsxMzUs MTAgQEAgc3RhdGljIHN0cnVjdCBrcHJvY19kZXNjIHBhZ2Vfa3AgPSB7CiBTWVNJTklUKHBhZ2Vk YWVtb24sIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX1NFQ09ORCwga3Byb2Nfc3RhcnQs CiAgICAgJnBhZ2Vfa3ApOwogCitTRFRfUFJPVklERVJfREVGSU5FKHZtKTsKK1NEVF9QUk9CRV9E RUZJTkUodm0sICwgLCB2bV9fbG93bWVtX2NhY2hlKTsKK1NEVF9QUk9CRV9ERUZJTkUodm0sICwg LCB2bV9fbG93bWVtX3NjYW4pOworCiAjaWYgIWRlZmluZWQoTk9fU1dBUFBJTkcpCiAvKiB0aGUg a2VybmVsIHByb2Nlc3MgInZtX2RhZW1vbiIqLwogc3RhdGljIHZvaWQgdm1fZGFlbW9uKHZvaWQp OwpAQCAtNjY3LDYgKzY3Myw3IEBAIHZtX3BhZ2VvdXRfZ3Jvd19jYWNoZShpbnQgdHJpZXMsIHZt X3BhZGRyX3QgbG93LCB2CiAJCSAqIG1heSBhY3F1aXJlIGxvY2tzIGFuZC9vciBzbGVlcCwgc28g dGhleSBjYW4gb25seSBiZSBpbnZva2VkCiAJCSAqIHdoZW4gInRyaWVzIiBpcyBncmVhdGVyIHRo YW4gemVyby4KIAkJICovCisJCVNEVF9QUk9CRTAodm0sICwgLCB2bV9fbG93bWVtX2NhY2hlKTsK IAkJRVZFTlRIQU5ETEVSX0lOVk9LRSh2bV9sb3dtZW0sIDApOwogCiAJCS8qCkBAIC04OTksNyAr OTA2LDcgQEAgdm1fcGFnZW91dF9tYXBfZGVhY3RpdmF0ZV9wYWdlcyhtYXAsIGRlc2lyZWQpCiAg KglwYXNzIDEgLSBNb3ZlIGluYWN0aXZlIHRvIGNhY2hlIG9yIGZyZWUKICAqCXBhc3MgMiAtIExh dW5kZXIgZGlydHkgcGFnZXMKICAqLwotc3RhdGljIHZvaWQKK3N0YXRpYyB2b2lkIF9fdXNlZAog dm1fcGFnZW91dF9zY2FuKHN0cnVjdCB2bV9kb21haW4gKnZtZCwgaW50IHBhc3MpCiB7CiAJdm1f cGFnZV90IG0sIG5leHQ7CkBAIC05MjAsNiArOTI3LDcgQEAgdm1fcGFnZW91dF9zY2FuKHN0cnVj dCB2bV9kb21haW4gKnZtZCwgaW50IHBhc3MpCiAJCS8qCiAJCSAqIERlY3JlYXNlIHJlZ2lzdGVy ZWQgY2FjaGUgc2l6ZXMuCiAJCSAqLworCQlTRFRfUFJPQkUwKHZtLCAsICwgdm1fX2xvd21lbV9z Y2FuKTsKIAkJRVZFTlRIQU5ETEVSX0lOVk9LRSh2bV9sb3dtZW0sIDApOwogCQkvKgogCQkgKiBX ZSBkbyB0aGlzIGV4cGxpY2l0bHkgYWZ0ZXIgdGhlIGNhY2hlcyBoYXZlIGJlZW4K 147068 2014-09-08 15:25:11 +0000 2014-09-08 15:25:11 +0000 ARC reclaim refactor (against stable/10) arc-reclaim-10.patch text/plain 15373 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MTExNikKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTMzLDEzICsx MzMsNiBAQCBrbWVtX3NpemUodm9pZCkKIAlyZXR1cm4gKGttZW1fc2l6ZV92YWwpOwogfQogCi11 aW50NjRfdAota21lbV91c2VkKHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtZW1fc2l6ZShrbWVtX2Fy ZW5hLCBWTUVNX0FMTE9DKSk7Ci19Ci0KIHN0YXRpYyBpbnQKIGttZW1fc3RkX2NvbnN0cnVjdG9y KHZvaWQgKm1lbSwgaW50IHNpemUgX191bnVzZWQsIHZvaWQgKnByaXZhdGUsIGludCBmbGFncykK IHsKSW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCShyZXZpc2lvbiAy NzExMTYpCisrKyBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMvc3lzL2ttZW0uaAkod29ya2lu ZyBjb3B5KQpAQCAtNjYsNyArNjYsNiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZv aWQgKnpmc19rbWVtX2FsbG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19r bWVtX2ZyZWUodm9pZCAqYnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9p ZCk7Ci11aW50NjRfdCBrbWVtX3VzZWQodm9pZCk7CiBrbWVtX2NhY2hlX3QgKmttZW1fY2FjaGVf Y3JlYXRlKGNoYXIgKm5hbWUsIHNpemVfdCBidWZzaXplLCBzaXplX3QgYWxpZ24sCiAgICAgaW50 ICgqY29uc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqLCBpbnQpLCB2b2lkICgqZGVzdHJ1Y3Rvciko dm9pZCAqLCB2b2lkICopLAogICAgIHZvaWQgKCpyZWNsYWltKSh2b2lkICopIF9fdW51c2VkLCB2 b2lkICpwcml2YXRlLCB2bWVtX3QgKnZtcCwgaW50IGNmbGFncyk7CkBAIC03OCw2ICs3Nyw5IEBA IHZvaWQga21lbV9yZWFwKHZvaWQpOwogaW50IGttZW1fZGVidWdnaW5nKHZvaWQpOwogdm9pZCAq Y2FsbG9jKHNpemVfdCBuLCBzaXplX3Qgcyk7CiAKKyNkZWZpbmUJZnJlZW1lbQkJCQkoY250LnZf ZnJlZV9jb3VudCArIGNudC52X2NhY2hlX2NvdW50KQorI2RlZmluZQltaW5mcmVlCQkJCWNudC52 X2ZyZWVfbWluCisjZGVmaW5lCWhlYXBfYXJlbmEJCQlrbWVtX2FyZW5hCiAjZGVmaW5lCWttZW1f YWxsb2Moc2l6ZSwga21mbGFncykJemZzX2ttZW1fYWxsb2MoKHNpemUpLCAoa21mbGFncykpCiAj ZGVmaW5lCWttZW1femFsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChzaXplKSwg KGttZmxhZ3MpIHwgTV9aRVJPKQogI2RlZmluZQlrbWVtX2ZyZWUoYnVmLCBzaXplKQkJemZzX2tt ZW1fZnJlZSgoYnVmKSwgKHNpemUpKQpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJp cy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmli L29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzExMTYpCisr KyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3 b3JraW5nIGNvcHkpCkBAIC0xMzgsNiArMTM4LDcgQEAKICNpbmNsdWRlIDxzeXMvc2R0Lmg+CiAK ICNpbmNsdWRlIDx2bS92bV9wYWdlb3V0Lmg+CisjaW5jbHVkZSA8bWFjaGluZS92bXBhcmFtLmg+ CiAKICNpZmRlZiBpbGx1bW9zCiAjaWZuZGVmIF9LRVJORUwKQEAgLTE5Myw5ICsxOTQsNiBAQCBl eHRlcm4gaW50IHpmc19wcmVmZXRjaF9kaXNhYmxlOwogICovCiBzdGF0aWMgYm9vbGVhbl90IGFy Y193YXJtOwogCi0vKgotICogVGhlc2UgdHVuYWJsZXMgYXJlIGZvciBwZXJmb3JtYW5jZSBhbmFs eXNpcy4KLSAqLwogdWludDY0X3QgemZzX2FyY19tYXg7CiB1aW50NjRfdCB6ZnNfYXJjX21pbjsK IHVpbnQ2NF90IHpmc19hcmNfbWV0YV9saW1pdCA9IDA7CkBAIC0yMDQsNyArMjAyLDIxIEBAIGlu dCB6ZnNfYXJjX3Nocmlua19zaGlmdCA9IDA7CiBpbnQgemZzX2FyY19wX21pbl9zaGlmdCA9IDA7 CiBpbnQgemZzX2Rpc2FibGVfZHVwX2V2aWN0aW9uID0gMDsKIHVpbnQ2NF90IHpmc19hcmNfYXZl cmFnZV9ibG9ja3NpemUgPSA4ICogMTAyNDsgLyogOEtCICovCit1X2ludCB6ZnNfYXJjX2ZyZWVf dGFyZ2V0ID0gKDEgPDwgMTYpOyAvKiBkZWZhdWx0IGJlZm9yZSBwYWdlZGFlbW9uIGluaXQgb25s eSAqLworaW50IHpmc19hcmNfcmVjbGFpbV9jYWNoZV9mcmVlID0gMTsKIAorc3RhdGljIGludCBz eXNjdGxfdmZzX3pmc19hcmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CisKKyNp ZmRlZiBfS0VSTkVMCitzdGF0aWMgdm9pZAorYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51 c2VkIF9fdW51c2VkKQoreworCisJemZzX2FyY19mcmVlX3RhcmdldCA9ICh2bV9wYWdlb3V0X3dh a2V1cF90aHJlc2ggLyAyKSAqIDM7Cit9CitTWVNJTklUKGFyY19mcmVlX3RhcmdldF9pbml0LCBT SV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9BTlksCisgICAgYXJjX2ZyZWVfdGFyZ2V0X2lu aXQsIE5VTEwpOworCiBUVU5BQkxFX1FVQUQoInZmcy56ZnMuYXJjX21heCIsICZ6ZnNfYXJjX21h eCk7CiBUVU5BQkxFX1FVQUQoInZmcy56ZnMuYXJjX21pbiIsICZ6ZnNfYXJjX21pbik7CiBUVU5B QkxFX1FVQUQoInZmcy56ZnMuYXJjX21ldGFfbGltaXQiLCAmemZzX2FyY19tZXRhX2xpbWl0KTsK QEAgLTIxNyw3ICsyMjksNDAgQEAgU1lTQ1RMX1VRVUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJj X21pbiwgQ1RMRkxBR18KIFNZU0NUTF9VUVVBRChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19hdmVy YWdlX2Jsb2Nrc2l6ZSwgQ1RMRkxBR19SRFRVTiwKICAgICAmemZzX2FyY19hdmVyYWdlX2Jsb2Nr c2l6ZSwgMCwKICAgICAiQVJDIGF2ZXJhZ2UgYmxvY2tzaXplIik7CitTWVNDVExfSU5UKF92ZnNf emZzLCBPSURfQVVUTywgYXJjX3JlY2xhaW1fY2FjaGVfZnJlZSwgQ1RMRkxBR19SV1RVTiwKKyAg ICAmemZzX2FyY19yZWNsYWltX2NhY2hlX2ZyZWUsIDAsCisgICAgIkFSQyB0cmVhdHMgY2FjaGVk IHBhZ2VzIGFzIGZyZWUgYmxvY2tzaXplIik7CisvKgorICogV2UgZG9uJ3QgaGF2ZSBhIHR1bmFi bGUgZm9yIGFyY19mcmVlX3RhcmdldCBkdWUgdG8gdGhlIGRlcGVuZGVuY3kgb24KKyAqIHBhZ2Vk YWVtb24gaW5pdGlhbGlzYXRpb24uCisgKi8KK1NZU0NUTF9QUk9DKF92ZnNfemZzLCBPSURfQVVU TywgYXJjX2ZyZWVfdGFyZ2V0LAorICAgIENUTFRZUEVfVUlOVCB8IENUTEZMQUdfTVBTQUZFIHwg Q1RMRkxBR19SVywgMCwgc2l6ZW9mKHVfaW50KSwKKyAgICBzeXNjdGxfdmZzX3pmc19hcmNfZnJl ZV90YXJnZXQsICJJVSIsCisgICAgIkRlc2lyZWQgbnVtYmVyIG9mIGZyZWUgcGFnZXMgYmVsb3cg d2hpY2ggQVJDIHRyaWdnZXJzIHJlY2xhaW0iKTsKIAorc3RhdGljIGludAorc3lzY3RsX3Zmc196 ZnNfYXJjX2ZyZWVfdGFyZ2V0KFNZU0NUTF9IQU5ETEVSX0FSR1MpCit7CisJdV9pbnQgdmFsOwor CWludCBlcnI7CisKKwl2YWwgPSB6ZnNfYXJjX2ZyZWVfdGFyZ2V0OworCWVyciA9IHN5c2N0bF9o YW5kbGVfaW50KG9pZHAsICZ2YWwsIDAsIHJlcSk7CisJaWYgKGVyciAhPSAwIHx8IHJlcS0+bmV3 cHRyID09IE5VTEwpCisJCXJldHVybiAoZXJyKTsKKworCWlmICh2YWwgPCBtaW5mcmVlKQorCQly ZXR1cm4gKEVJTlZBTCk7CisJaWYgKHZhbCA+IGNudC52X3BhZ2VfY291bnQpCisJCXJldHVybiAo RUlOVkFMKTsKKworCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2YWw7CisKKwlyZXR1cm4gKDApOwor fQorI2VuZGlmCisKIC8qCiAgKiBOb3RlIHRoYXQgYnVmZmVycyBjYW4gYmUgaW4gb25lIG9mIDYg c3RhdGVzOgogICoJQVJDX2Fub24JLSBhbm9ueW1vdXMgKGRpc2N1c3NlZCBiZWxvdykKQEAgLTI0 MjEsNiArMjQ2Niw3IEBAIGFyY19mbHVzaChzcGFfdCAqc3BhKQogdm9pZAogYXJjX3Nocmluayh2 b2lkKQogeworCiAJaWYgKGFyY19jID4gYXJjX2NfbWluKSB7CiAJCXVpbnQ2NF90IHRvX2ZyZWU7 CiAKQEAgLTI0MjksNiArMjQ3NSw5IEBAIGFyY19zaHJpbmsodm9pZCkKICNlbHNlCiAJCXRvX2Zy ZWUgPSBhcmNfYyA+PiBhcmNfc2hyaW5rX3NoaWZ0OwogI2VuZGlmCisJCURUUkFDRV9QUk9CRTQo YXJjX19zaHJpbmssIHVpbnQ2NF90LCBhcmNfYywgdWludDY0X3QsCisJCQlhcmNfY19taW4sIHVp bnQ2NF90LCBhcmNfcCwgdWludDY0X3QsIHRvX2ZyZWUpOworCiAJCWlmIChhcmNfYyA+IGFyY19j X21pbiArIHRvX2ZyZWUpCiAJCQlhdG9taWNfYWRkXzY0KCZhcmNfYywgLXRvX2ZyZWUpOwogCQll bHNlCkBAIC0yNDM5LDEyICsyNDg4LDE5IEBAIGFyY19zaHJpbmsodm9pZCkKIAkJCWFyY19jID0g TUFYKGFyY19zaXplLCBhcmNfY19taW4pOwogCQlpZiAoYXJjX3AgPiBhcmNfYykKIAkJCWFyY19w ID0gKGFyY19jID4+IDEpOworCisJCURUUkFDRV9QUk9CRTIoYXJjX19zaHJ1bmssIHVpbnQ2NF90 LCBhcmNfYywgdWludDY0X3QsCisJCQlhcmNfcCk7CisKIAkJQVNTRVJUKGFyY19jID49IGFyY19j X21pbik7CiAJCUFTU0VSVCgoaW50NjRfdClhcmNfcCA+PSAwKTsKIAl9CiAKLQlpZiAoYXJjX3Np emUgPiBhcmNfYykKKwlpZiAoYXJjX3NpemUgPiBhcmNfYykgeworCQlEVFJBQ0VfUFJPQkUyKGFy Y19fc2hyaW5rX2FkanVzdCwgdWludDY0X3QsIGFyY19zaXplLAorCQkJdWludDY0X3QsIGFyY19j KTsKIAkJYXJjX2FkanVzdCgpOworCX0KIH0KIAogc3RhdGljIGludCBuZWVkZnJlZSA9IDA7CkBA IC0yNDUyLDE4ICsyNTA4LDM1IEBAIHN0YXRpYyBpbnQgbmVlZGZyZWUgPSAwOwogc3RhdGljIGlu dAogYXJjX3JlY2xhaW1fbmVlZGVkKHZvaWQpCiB7CisJdV9pbnQgZm07CiAKICNpZmRlZiBfS0VS TkVMCisJaWYgKGFyY19zaXplIDw9IGFyY19jX21pbikgeworCQlEVFJBQ0VfUFJPQkUyKGFyY19f cmVjbGFpbV9taW4sIHVpbnQ2NF90LCBhcmNfc2l6ZSwKKwkJICAgIHVpbnQ2NF90LCBhcmNfY19t aW4pOworCQlyZXR1cm4gKDApOworCX0KIAotCWlmIChuZWVkZnJlZSkKKwlpZiAobmVlZGZyZWUp IHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9uZWVkZnJlZSk7CiAJCXJldHVybiAoMSk7 CisJfQogCiAJLyoKIAkgKiBDb29wZXJhdGUgd2l0aCBwYWdlZGFlbW9uIHdoZW4gaXQncyB0aW1l IGZvciBpdCB0byBzY2FuCiAJICogYW5kIHJlY2xhaW0gc29tZSBwYWdlcy4KIAkgKi8KLQlpZiAo dm1fcGFnaW5nX25lZWRlZCgpKQorCWlmICh6ZnNfYXJjX3JlY2xhaW1fY2FjaGVfZnJlZSA9PSAw KQorCQlmbSA9IGNudC52X2ZyZWVfY291bnQ7CisJZWxzZQorCQlmbSA9IGZyZWVtZW07CisKKwlp ZiAoZm0gPCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KSB7CisJCURUUkFDRV9QUk9CRTMoYXJjX19yZWNs YWltX2ZyZWVtZW0sIHVpbnQ2NF90LAorCQkgICAgZm0sIHVpbnQ2NF90LCB6ZnNfYXJjX2ZyZWVf dGFyZ2V0LAorCQkgICAgaW50LCB6ZnNfYXJjX3JlY2xhaW1fY2FjaGVfZnJlZSk7CiAJCXJldHVy biAoMSk7CisJfQogCiAjaWZkZWYgc3VuCiAJLyoKQEAgLTI0OTEsOCArMjU2NCwxOSBAQCBhcmNf cmVjbGFpbV9uZWVkZWQodm9pZCkKIAlpZiAoYXZhaWxybWVtIDwgc3dhcGZzX21pbmZyZWUgKyBz d2FwZnNfcmVzZXJ2ZSArIGV4dHJhKQogCQlyZXR1cm4gKDEpOwogCi0jaWYgZGVmaW5lZChfX2kz ODYpCiAJLyoKKwkgKiBDaGVjayB0aGF0IHdlIGhhdmUgZW5vdWdoIGF2YWlscm1lbSB0aGF0IG1l bW9yeSBsb2NraW5nIChlLmcuLCB2aWEKKwkgKiBtbG9jaygzQykgb3IgbWVtY250bCgyKSkgY2Fu IHN0aWxsIHN1Y2NlZWQuICAocGFnZXNfcHBfbWF4aW11bQorCSAqIHN0b3JlcyB0aGUgbnVtYmVy IG9mIHBhZ2VzIHRoYXQgY2Fubm90IGJlIGxvY2tlZDsgd2hlbiBhdmFpbHJtZW0KKwkgKiBkcm9w cyBiZWxvdyBwYWdlc19wcF9tYXhpbXVtLCBwYWdlIGxvY2tpbmcgbWVjaGFuaXNtcyBzdWNoIGFz CisJICogcGFnZV9wcF9sb2NrKCkgd2lsbCBmYWlsLikKKwkgKi8KKwlpZiAoYXZhaWxybWVtIDw9 IHBhZ2VzX3BwX21heGltdW0pCisJCXJldHVybiAoMSk7CisKKyNlbmRpZgkvKiBzdW4gKi8KKyNp ZiBkZWZpbmVkKF9faTM4NikgfHwgIWRlZmluZWQoVU1BX01EX1NNQUxMX0FMTE9DKQorCS8qCiAJ ICogSWYgd2UncmUgb24gYW4gaTM4NiBwbGF0Zm9ybSwgaXQncyBwb3NzaWJsZSB0aGF0IHdlJ2xs IGV4aGF1c3QgdGhlCiAJICoga2VybmVsIGhlYXAgc3BhY2UgYmVmb3JlIHdlIGV2ZXIgcnVuIG91 dCBvZiBhdmFpbGFibGUgcGh5c2ljYWwKIAkgKiBtZW1vcnkuICBNb3N0IGNoZWNrcyBvZiB0aGUg c2l6ZSBvZiB0aGUgaGVhcF9hcmVhIGNvbXBhcmUgYWdhaW5zdApAQCAtMjUwMywxOSArMjU4Nywz NSBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIAkgKiBoZWFwIGlzIGFsbG9jYXRlZC4gIChP ciwgaW4gdGhlIGNhbGN1bGF0aW9uLCBpZiBsZXNzIHRoYW4gMS80dGggaXMKIAkgKiBmcmVlKQog CSAqLwotCWlmIChidG9wKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpKSA8Ci0JICAg IChidG9wKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUgfCBWTUVNX0FMTE9DKSkgPj4g MikpCisJaWYgKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpIDwKKwkgICAgKHZtZW1f c2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUgfCBWTUVNX0FMTE9DKSA+PiAyKSkgeworCQlEVFJB Q0VfUFJPQkUyKGFyY19fcmVjbGFpbV91c2VkLCB1aW50NjRfdCwKKwkJICAgIHZtZW1fc2l6ZSho ZWFwX2FyZW5hLCBWTUVNX0ZSRUUpLCB1aW50NjRfdCwKKwkJICAgICh2bWVtX3NpemUoaGVhcF9h cmVuYSwgVk1FTV9GUkVFIHwgVk1FTV9BTExPQykpID4+IDIpOwogCQlyZXR1cm4gKDEpOworCX0K ICNlbmRpZgotI2Vsc2UJLyogIXN1biAqLwotCWlmIChrbWVtX3VzZWQoKSA+IChrbWVtX3NpemUo KSAqIDMpIC8gNCkKKyNpZmRlZiBzdW4KKwkvKgorCSAqIElmIHppbyBkYXRhIHBhZ2VzIGFyZSBi ZWluZyBhbGxvY2F0ZWQgb3V0IG9mIGEgc2VwYXJhdGUgaGVhcCBzZWdtZW50LAorCSAqIHRoZW4g ZW5mb3JjZSB0aGF0IHRoZSBzaXplIG9mIGF2YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFyZW5hIHJl bWFpbnMKKwkgKiBhYm92ZSBhYm91dCAxLzE2dGggZnJlZS4KKwkgKgorCSAqIE5vdGU6IFRoZSAx LzE2dGggYXJlbmEgZnJlZSByZXF1aXJlbWVudCB3YXMgcHV0IGluIHBsYWNlCisJICogdG8gYWdn cmVzc2l2ZWx5IGV2aWN0IG1lbW9yeSBmcm9tIHRoZSBhcmMgaW4gb3JkZXIgdG8gYXZvaWQKKwkg KiBtZW1vcnkgZnJhZ21lbnRhdGlvbiBpc3N1ZXMuCisJICovCisJaWYgKHppb19hcmVuYSAhPSBO VUxMICYmCisJICAgIHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fRlJFRSkgPAorCSAgICAodm1l bV9zaXplKHppb19hcmVuYSwgVk1FTV9BTExPQykgPj4gNCkpCiAJCXJldHVybiAoMSk7CiAjZW5k aWYJLyogc3VuICovCi0KLSNlbHNlCisjZWxzZQkvKiBfS0VSTkVMICovCiAJaWYgKHNwYV9nZXRf cmFuZG9tKDEwMCkgPT0gMCkKIAkJcmV0dXJuICgxKTsKLSNlbmRpZgorI2VuZGlmCS8qIF9LRVJO RUwgKi8KKwlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX25vKTsKKwogCXJldHVybiAoMCk7CiB9 CiAKQEAgLTI1MjIsNyArMjYyMiw3IEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogZXh0ZXJu IGttZW1fY2FjaGVfdAkqemlvX2J1Zl9jYWNoZVtdOwogZXh0ZXJuIGttZW1fY2FjaGVfdAkqemlv X2RhdGFfYnVmX2NhY2hlW107CiAKLXN0YXRpYyB2b2lkCitzdGF0aWMgdm9pZCBfX3VzZWQKIGFy Y19rbWVtX3JlYXBfbm93KGFyY19yZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiB7CiAJc2l6ZV90 CQkJaTsKQEAgLTI1MjksNiArMjYyOSw3IEBAIGFyY19rbWVtX3JlYXBfbm93KGFyY19yZWNsYWlt X3N0cmF0ZWd5X3Qgc3RyYXQpCiAJa21lbV9jYWNoZV90CQkqcHJldl9jYWNoZSA9IE5VTEw7CiAJ a21lbV9jYWNoZV90CQkqcHJldl9kYXRhX2NhY2hlID0gTlVMTDsKIAorCURUUkFDRV9QUk9CRShh cmNfX2ttZW1fcmVhcF9zdGFydCk7CiAjaWZkZWYgX0tFUk5FTAogCWlmIChhcmNfbWV0YV91c2Vk ID49IGFyY19tZXRhX2xpbWl0KSB7CiAJCS8qCkBAIC0yNTY0LDYgKzI2NjUsMTYgQEAgYXJjX2tt ZW1fcmVhcF9ub3coYXJjX3JlY2xhaW1fc3RyYXRlZ3lfdCBzdHJhdCkKIAl9CiAJa21lbV9jYWNo ZV9yZWFwX25vdyhidWZfY2FjaGUpOwogCWttZW1fY2FjaGVfcmVhcF9ub3coaGRyX2NhY2hlKTsK KworI2lmZGVmIHN1bgorCS8qCisJICogQXNrIHRoZSB2bWVtIGFyZWFuYSB0byByZWNsYWltIHVu dXNlZCBtZW1vcnkgZnJvbSBpdHMKKwkgKiBxdWFudHVtIGNhY2hlcy4KKwkgKi8KKwlpZiAoemlv X2FyZW5hICE9IE5VTEwgJiYgc3RyYXQgPT0gQVJDX1JFQ0xBSU1fQUdHUikKKwkJdm1lbV9xY2Fj aGVfcmVhcCh6aW9fYXJlbmEpOworI2VuZGlmCisJRFRSQUNFX1BST0JFKGFyY19fa21lbV9yZWFw X2VuZCk7CiB9CiAKIHN0YXRpYyB2b2lkCkBAIC0yNTgxLDYgKzI2OTIsNyBAQCBhcmNfcmVjbGFp bV90aHJlYWQodm9pZCAqZHVtbXkgX191bnVzZWQpCiAKIAkJCWlmIChhcmNfbm9fZ3Jvdykgewog CQkJCWlmIChsYXN0X3JlY2xhaW0gPT0gQVJDX1JFQ0xBSU1fQ09OUykgeworCQkJCQlEVFJBQ0Vf UFJPQkUoYXJjX19yZWNsYWltX2FnZ3Jfbm9fZ3Jvdyk7CiAJCQkJCWxhc3RfcmVjbGFpbSA9IEFS Q19SRUNMQUlNX0FHR1I7CiAJCQkJfSBlbHNlIHsKIAkJCQkJbGFzdF9yZWNsYWltID0gQVJDX1JF Q0xBSU1fQ09OUzsKQEAgLTI1ODgsNiArMjcwMCw3IEBAIGFyY19yZWNsYWltX3RocmVhZCh2b2lk ICpkdW1teSBfX3VudXNlZCkKIAkJCX0gZWxzZSB7CiAJCQkJYXJjX25vX2dyb3cgPSBUUlVFOwog CQkJCWxhc3RfcmVjbGFpbSA9IEFSQ19SRUNMQUlNX0FHR1I7CisJCQkJRFRSQUNFX1BST0JFKGFy Y19fcmVjbGFpbV9hZ2dyKTsKIAkJCQltZW1iYXJfcHJvZHVjZXIoKTsKIAkJCX0KIApAQCAtMjYw Miw2ICsyNzE1LDcgQEAgYXJjX3JlY2xhaW1fdGhyZWFkKHZvaWQgKmR1bW15IF9fdW51c2VkKQog CQkJCSAqLwogCQkJCWFyY19ub19ncm93ID0gVFJVRTsKIAkJCQlsYXN0X3JlY2xhaW0gPSBBUkNf UkVDTEFJTV9BR0dSOworCQkJCURUUkFDRV9QUk9CRShhcmNfX3JlY2xhaW1fYWdncl9uZWVkZnJl ZSk7CiAJCQl9CiAJCQlhcmNfa21lbV9yZWFwX25vdyhsYXN0X3JlY2xhaW0pOwogCQkJYXJjX3dh cm0gPSBCX1RSVUU7CkBAIC0yNjE4LDYgKzI3MzIsNyBAQCBhcmNfcmVjbGFpbV90aHJlYWQodm9p ZCAqZHVtbXkgX191bnVzZWQpCiAjaWZkZWYgX0tFUk5FTAogCQlpZiAobmVlZGZyZWUpIHsKIAkJ CW5lZWRmcmVlID0gMDsKKwkJCURUUkFDRV9QUk9CRShhcmNfX2NsZWFyX25lZWRmcmVlKTsKIAkJ CXdha2V1cCgmbmVlZGZyZWUpOwogCQl9CiAjZW5kaWYKQEAgLTI2OTIsNiArMjgwNyw3IEBAIGFy Y19hZGFwdChpbnQgYnl0ZXMsIGFyY19zdGF0ZV90ICpzdGF0ZSkKIAkgKiBjYWNoZSBzaXplLCBp bmNyZW1lbnQgdGhlIHRhcmdldCBjYWNoZSBzaXplCiAJICovCiAJaWYgKGFyY19zaXplID4gYXJj X2MgLSAoMlVMTCA8PCBTUEFfTUFYQkxPQ0tTSElGVCkpIHsKKwkJRFRSQUNFX1BST0JFMShhcmNf X2luY19hZGFwdCwgaW50LCBieXRlcyk7CiAJCWF0b21pY19hZGRfNjQoJmFyY19jLCAoaW50NjRf dClieXRlcyk7CiAJCWlmIChhcmNfYyA+IGFyY19jX21heCkKIAkJCWFyY19jID0gYXJjX2NfbWF4 OwpAQCAtMjcxMywyMCArMjgyOSw2IEBAIGFyY19ldmljdF9uZWVkZWQoYXJjX2J1Zl9jb250ZW50 c190IHR5cGUpCiAJaWYgKHR5cGUgPT0gQVJDX0JVRkNfTUVUQURBVEEgJiYgYXJjX21ldGFfdXNl ZCA+PSBhcmNfbWV0YV9saW1pdCkKIAkJcmV0dXJuICgxKTsKIAotI2lmZGVmIHN1bgotI2lmZGVm IF9LRVJORUwKLQkvKgotCSAqIElmIHppbyBkYXRhIHBhZ2VzIGFyZSBiZWluZyBhbGxvY2F0ZWQg b3V0IG9mIGEgc2VwYXJhdGUgaGVhcCBzZWdtZW50LAotCSAqIHRoZW4gZW5mb3JjZSB0aGF0IHRo ZSBzaXplIG9mIGF2YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFyZWEgcmVtYWlucwotCSAqIGFib3Zl IGFib3V0IDEvMzJuZCBmcmVlLgotCSAqLwotCWlmICh0eXBlID09IEFSQ19CVUZDX0RBVEEgJiYg emlvX2FyZW5hICE9IE5VTEwgJiYKLQkgICAgdm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9GUkVF KSA8Ci0JICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0FMTE9DKSA+PiA1KSkKLQkJcmV0 dXJuICgxKTsKLSNlbmRpZgotI2VuZGlmCS8qIHN1biAqLwotCiAJaWYgKGFyY19yZWNsYWltX25l ZWRlZCgpKQogCQlyZXR1cm4gKDEpOwogCkBAIC0zODg1LDIwICszOTg3LDE2IEBAIHN0YXRpYyBp bnQKIGFyY19tZW1vcnlfdGhyb3R0bGUodWludDY0X3QgcmVzZXJ2ZSwgdWludDY0X3QgdHhnKQog ewogI2lmZGVmIF9LRVJORUwKLQl1aW50NjRfdCBhdmFpbGFibGVfbWVtb3J5ID0KLQkgICAgcHRv YSgodWludG1heF90KWNudC52X2ZyZWVfY291bnQgKyBjbnQudl9jYWNoZV9jb3VudCk7CisJdWlu dDY0X3QgYXZhaWxhYmxlX21lbW9yeSA9IHB0b2IoZnJlZW1lbSk7CiAJc3RhdGljIHVpbnQ2NF90 IHBhZ2VfbG9hZCA9IDA7CiAJc3RhdGljIHVpbnQ2NF90IGxhc3RfdHhnID0gMDsKIAotI2lmZGVm IHN1bgotI2lmIGRlZmluZWQoX19pMzg2KQorI2lmIGRlZmluZWQoX19pMzg2KSB8fCAhZGVmaW5l ZChVTUFfTURfU01BTExfQUxMT0MpCiAJYXZhaWxhYmxlX21lbW9yeSA9Ci0JICAgIE1JTihhdmFp bGFibGVfbWVtb3J5LCB2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSk7CisJICAgIE1J TihhdmFpbGFibGVfbWVtb3J5LCBwdG9iKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUp KSk7CiAjZW5kaWYKLSNlbmRpZgkvKiBzdW4gKi8KIAotCWlmIChjbnQudl9mcmVlX2NvdW50ICsg Y250LnZfY2FjaGVfY291bnQgPgotCSAgICAodWludDY0X3QpcGh5c21lbSAqIGFyY19sb3RzZnJl ZV9wZXJjZW50IC8gMTAwKQorCWlmIChmcmVlbWVtID4gKHVpbnQ2NF90KXBoeXNtZW0gKiBhcmNf bG90c2ZyZWVfcGVyY2VudCAvIDEwMCkKIAkJcmV0dXJuICgwKTsKIAogCWlmICh0eGcgPiBsYXN0 X3R4ZykgewpAQCAtMzkxMSw3ICs0MDA5LDcgQEAgYXJjX21lbW9yeV90aHJvdHRsZSh1aW50NjRf dCByZXNlcnZlLCB1aW50NjRfdCB0eGcKIAkgKiBjb250aW51ZSB0byBsZXQgcGFnZSB3cml0ZXMg b2NjdXIgYXMgcXVpY2tseSBhcyBwb3NzaWJsZS4KIAkgKi8KIAlpZiAoY3VycHJvYyA9PSBwYWdl cHJvYykgewotCQlpZiAocGFnZV9sb2FkID4gYXZhaWxhYmxlX21lbW9yeSAvIDQpCisJCWlmIChw YWdlX2xvYWQgPiBNQVgocHRvYihtaW5mcmVlKSwgYXZhaWxhYmxlX21lbW9yeSkgLyA0KQogCQkJ cmV0dXJuIChTRVRfRVJST1IoRVJFU1RBUlQpKTsKIAkJLyogTm90ZTogcmVzZXJ2ZSBpcyBpbmZs YXRlZCwgc28gd2UgZGVmbGF0ZSAqLwogCQlwYWdlX2xvYWQgKz0gcmVzZXJ2ZSAvIDg7CkBAIC0z OTM5LDggKzQwMzcsMTAgQEAgYXJjX3RlbXByZXNlcnZlX3NwYWNlKHVpbnQ2NF90IHJlc2VydmUs IHVpbnQ2NF90IHQKIAlpbnQgZXJyb3I7CiAJdWludDY0X3QgYW5vbl9zaXplOwogCi0JaWYgKHJl c2VydmUgPiBhcmNfYy80ICYmICFhcmNfbm9fZ3JvdykKKwlpZiAocmVzZXJ2ZSA+IGFyY19jLzQg JiYgIWFyY19ub19ncm93KSB7CiAJCWFyY19jID0gTUlOKGFyY19jX21heCwgcmVzZXJ2ZSAqIDQp OworCQlEVFJBQ0VfUFJPQkUxKGFyY19fc2V0X3Jlc2VydmUsIHVpbnQ2NF90LCBhcmNfYyk7CisJ fQogCWlmIChyZXNlcnZlID4gYXJjX2MpCiAJCXJldHVybiAoU0VUX0VSUk9SKEVOT01FTSkpOwog CkBAIC0zOTk0LDYgKzQwOTQsNyBAQCBhcmNfbG93bWVtKHZvaWQgKmFyZyBfX3VudXNlZCwgaW50 IGhvd3RvIF9fdW51c2VkKQogCW11dGV4X2VudGVyKCZhcmNfbG93bWVtX2xvY2spOwogCW11dGV4 X2VudGVyKCZhcmNfcmVjbGFpbV90aHJfbG9jayk7CiAJbmVlZGZyZWUgPSAxOworCURUUkFDRV9Q Uk9CRShhcmNfX25lZWRmcmVlKTsKIAljdl9zaWduYWwoJmFyY19yZWNsYWltX3Rocl9jdik7CiAK IAkvKgpJbmRleDogc3lzL3ZtL3ZtX3BhZ2VvdXQuYwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvdm0vdm1f cGFnZW91dC5jCShyZXZpc2lvbiAyNzExMTYpCisrKyBzeXMvdm0vdm1fcGFnZW91dC5jCSh3b3Jr aW5nIGNvcHkpCkBAIC03Niw2ICs3Niw3IEBACiBfX0ZCU0RJRCgiJEZyZWVCU0QkIik7CiAKICNp bmNsdWRlICJvcHRfdm0uaCIKKyNpbmNsdWRlICJvcHRfa2R0cmFjZS5oIgogI2luY2x1ZGUgPHN5 cy9wYXJhbS5oPgogI2luY2x1ZGUgPHN5cy9zeXN0bS5oPgogI2luY2x1ZGUgPHN5cy9rZXJuZWwu aD4KQEAgLTg5LDYgKzkwLDcgQEAgX19GQlNESUQoIiRGcmVlQlNEJCIpOwogI2luY2x1ZGUgPHN5 cy9yYWNjdC5oPgogI2luY2x1ZGUgPHN5cy9yZXNvdXJjZXZhci5oPgogI2luY2x1ZGUgPHN5cy9z Y2hlZC5oPgorI2luY2x1ZGUgPHN5cy9zZHQuaD4KICNpbmNsdWRlIDxzeXMvc2lnbmFsdmFyLmg+ CiAjaW5jbHVkZSA8c3lzL3NtcC5oPgogI2luY2x1ZGUgPHN5cy92bm9kZS5oPgpAQCAtMTE1LDEw ICsxMTcsMTQgQEAgX19GQlNESUQoIiRGcmVlQlNEJCIpOwogCiAvKiB0aGUga2VybmVsIHByb2Nl c3MgInZtX3BhZ2VvdXQiKi8KIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXQodm9pZCk7CitzdGF0aWMg dm9pZCB2bV9wYWdlb3V0X2luaXQodm9pZCk7CiBzdGF0aWMgaW50IHZtX3BhZ2VvdXRfY2xlYW4o dm1fcGFnZV90KTsKIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXRfc2NhbihzdHJ1Y3Qgdm1fZG9tYWlu ICp2bWQsIGludCBwYXNzKTsKIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXRfbWlnaHRiZV9vb20oc3Ry dWN0IHZtX2RvbWFpbiAqdm1kLCBpbnQgcGFzcyk7CiAKK1NZU0lOSVQocGFnZWRhZW1vbl9pbml0 LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9GSVJTVCwgdm1fcGFnZW91dF9pbml0LAor ICAgIE5VTEwpOworCiBzdHJ1Y3QgcHJvYyAqcGFnZXByb2M7CiAKIHN0YXRpYyBzdHJ1Y3Qga3By b2NfZGVzYyBwYWdlX2twID0gewpAQCAtMTI2LDkgKzEzMiwxMyBAQCBzdGF0aWMgc3RydWN0IGtw cm9jX2Rlc2MgcGFnZV9rcCA9IHsKIAl2bV9wYWdlb3V0LAogCSZwYWdlcHJvYwogfTsKLVNZU0lO SVQocGFnZWRhZW1vbiwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfRklSU1QsIGtwcm9j X3N0YXJ0LAorU1lTSU5JVChwYWdlZGFlbW9uLCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRF Ul9TRUNPTkQsIGtwcm9jX3N0YXJ0LAogICAgICZwYWdlX2twKTsKIAorU0RUX1BST1ZJREVSX0RF RklORSh2bSk7CitTRFRfUFJPQkVfREVGSU5FKHZtLCAsICwgdm1fX2xvd21lbV9jYWNoZSk7CitT RFRfUFJPQkVfREVGSU5FKHZtLCAsICwgdm1fX2xvd21lbV9zY2FuKTsKKwogI2lmICFkZWZpbmVk KE5PX1NXQVBQSU5HKQogLyogdGhlIGtlcm5lbCBwcm9jZXNzICJ2bV9kYWVtb24iKi8KIHN0YXRp YyB2b2lkIHZtX2RhZW1vbih2b2lkKTsKQEAgLTY2Myw2ICs2NzMsNyBAQCB2bV9wYWdlb3V0X2dy b3dfY2FjaGUoaW50IHRyaWVzLCB2bV9wYWRkcl90IGxvdywgdgogCQkgKiBtYXkgYWNxdWlyZSBs b2NrcyBhbmQvb3Igc2xlZXAsIHNvIHRoZXkgY2FuIG9ubHkgYmUgaW52b2tlZAogCQkgKiB3aGVu ICJ0cmllcyIgaXMgZ3JlYXRlciB0aGFuIHplcm8uCiAJCSAqLworCQlTRFRfUFJPQkUwKHZtLCAs ICwgdm1fX2xvd21lbV9jYWNoZSk7CiAJCUVWRU5USEFORExFUl9JTlZPS0Uodm1fbG93bWVtLCAw KTsKIAogCQkvKgpAQCAtOTA0LDcgKzkxNSw3IEBAIHZtX3BhZ2VvdXRfbWFwX2RlYWN0aXZhdGVf cGFnZXMobWFwLCBkZXNpcmVkKQogICoJcGFzcyAxIC0gTW92ZSBpbmFjdGl2ZSB0byBjYWNoZSBv ciBmcmVlCiAgKglwYXNzIDIgLSBMYXVuZGVyIGRpcnR5IHBhZ2VzCiAgKi8KLXN0YXRpYyB2b2lk CitzdGF0aWMgdm9pZCBfX3VzZWQKIHZtX3BhZ2VvdXRfc2NhbihzdHJ1Y3Qgdm1fZG9tYWluICp2 bWQsIGludCBwYXNzKQogewogCXZtX3BhZ2VfdCBtLCBuZXh0OwpAQCAtOTI1LDYgKzkzNiw3IEBA IHZtX3BhZ2VvdXRfc2NhbihzdHJ1Y3Qgdm1fZG9tYWluICp2bWQsIGludCBwYXNzKQogCQkvKgog CQkgKiBEZWNyZWFzZSByZWdpc3RlcmVkIGNhY2hlIHNpemVzLgogCQkgKi8KKwkJU0RUX1BST0JF MCh2bSwgLCAsIHZtX19sb3dtZW1fc2Nhbik7CiAJCUVWRU5USEFORExFUl9JTlZPS0Uodm1fbG93 bWVtLCAwKTsKIAkJLyoKIAkJICogV2UgZG8gdGhpcyBleHBsaWNpdGx5IGFmdGVyIHRoZSBjYWNo ZXMgaGF2ZSBiZWVuCkBAIC0xNjUwLDE1ICsxNjYyLDExIEBAIHZtX3BhZ2VvdXRfd29ya2VyKHZv aWQgKmFyZykKIH0KIAogLyoKLSAqCXZtX3BhZ2VvdXQgaXMgdGhlIGhpZ2ggbGV2ZWwgcGFnZW91 dCBkYWVtb24uCisgKgl2bV9wYWdlb3V0X2luaXQgaW5pdGlhbGlzZXMgYmFzaWMgcGFnZW91dCBk YWVtb24gc2V0dGluZ3MuCiAgKi8KIHN0YXRpYyB2b2lkCi12bV9wYWdlb3V0KHZvaWQpCit2bV9w YWdlb3V0X2luaXQodm9pZCkKIHsKLSNpZiBNQVhNRU1ET00gPiAxCi0JaW50IGVycm9yLCBpOwot I2VuZGlmCi0KIAkvKgogCSAqIEluaXRpYWxpemUgc29tZSBwYWdpbmcgcGFyYW1ldGVycy4KIAkg Ki8KQEAgLTE3MDQsNyArMTcxMiwxOCBAQCBzdGF0aWMgdm9pZAogCS8qIFhYWCBkb2VzIG5vdCBy ZWFsbHkgYmVsb25nIGhlcmUgKi8KIAlpZiAodm1fcGFnZV9tYXhfd2lyZWQgPT0gMCkKIAkJdm1f cGFnZV9tYXhfd2lyZWQgPSBjbnQudl9mcmVlX2NvdW50IC8gMzsKK30KIAorLyoKKyAqICAgICB2 bV9wYWdlb3V0IGlzIHRoZSBoaWdoIGxldmVsIHBhZ2VvdXQgZGFlbW9uLgorICovCitzdGF0aWMg dm9pZAordm1fcGFnZW91dCh2b2lkKQoreworI2lmIE1BWE1FTURPTSA+IDEKKwlpbnQgZXJyb3Is IGk7CisjZW5kaWYKKwogCXN3YXBfcGFnZXJfc3dhcF9pbml0KCk7CiAjaWYgTUFYTUVNRE9NID4g MQogCWZvciAoaSA9IDE7IGkgPCB2bV9uZG9tYWluczsgaSsrKSB7Cg== 147069 2014-09-08 15:27:29 +0000 2014-09-08 15:27:29 +0000 ARC resize dtrace script arc-resize.d text/plain 956 smh IyEvdXNyL3NiaW4vZHRyYWNlIC1zCgpzZHQ6OjphcmMtc2hyaW5rCnsKICAgICAgICBwcmludGYo IiVZIGFyY19jOiAlbGQgPCBhcmNfY19taW46ICVsZCA9PiBhcmNfcDogJWxkLCB0b19mcmVlOiAl bGQiLCB3YWxsdGltZXN0YW1wLCBhcmcwLCBhcmcxLCBhcmcyLCBhcmczKTsKfQoKc2R0Ojo6YXJj LXNocmlua19hZGp1c3QKewogICAgICAgIHByaW50ZigiJVkgYXJjX3NpemU6ICVsZCA8IGFyY19j OiAlbGQiLCB3YWxsdGltZXN0YW1wLCBhcmcwLCBhcmcxKQp9CgpzZHQ6OjphcmMtc2hydW5rCnsK ICAgICAgICBwcmludGYoIiVZIGFyY19jOiAlbGQgYXJjX3A6ICVsZCIsIHdhbGx0aW1lc3RhbXAs IGFyZzAsIGFyZzEpCn0KLyoKc2R0Ojo6YXJjLWluY19hZGFwdAp7CiAgICAgICAgcHJpbnRmKCIl WSBieXRlczogJWxkIiwgd2FsbHRpbWVzdGFtcCwgYXJnMCkKfQoqLwpzZHQ6OjphcmMtc2V0X3Jl c2VydmUKewogICAgICAgIHByaW50ZigiJVkgYXJjX2M6ICVsZCIsIHdhbGx0aW1lc3RhbXAsIGFy ZzApCn0KCnNkdDo6OmFyYy1yZWNsYWltX21pbiwKc2R0Ojo6YXJjLW5lZWRmcmVlLApzZHQ6Ojph cmMtcmVjbGFpbV9hZ2dyX25vX2dyb3csCnNkdDo6OmFyYy1yZWNsYWltX2FnZ3IsCnNkdDo6OmFy Yy1yZWNsYWltX2FnZ3JfbmVlZGZyZWUsCnNkdDo6OmFyYy1jbGVhcl9uZWVkZnJlZSwKdm06Ojp2 bS1sb3dtZW1fY2FjaGUsCnZtOjo6dm0tbG93bWVtX3NjYW4KewogICAgICAgIHByaW50ZigiJVki LCB3YWxsdGltZXN0YW1wKQp9CgpzZHQ6OjphcmMtcmVjbGFpbV9uZWVkZnJlZQp7CiAgICAgICAg cHJpbnRmKCIlWSIsIHdhbGx0aW1lc3RhbXApOwovKglzdGFjaygpKi8KfQoKc2R0Ojo6YXJjLXJl Y2xhaW1fZnJlZW1lbQp7CiAgICAgICAgcHJpbnRmKCIlWSBmbTogJWxkIDwgemZzX2FyY19mcmVl X3RhcmdldDogJWxkIiwgd2FsbHRpbWVzdGFtcCwgYXJnMCwgYXJnMSkKfQo= 147070 2014-09-08 15:29:46 +0000 2014-09-08 15:29:46 +0000 ARC reclaim refactor (against head) arc-reclaim-head.patch text/plain 13477 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MDg3NSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTI2LDQyICsx MjYsNiBAQCBrbWVtX3NpemVfaW5pdCh2b2lkICp1bnVzZWQgX191bnVzZWQpCiB9CiBTWVNJTklU KGttZW1fc2l6ZV9pbml0LCBTSV9TVUJfS01FTSwgU0lfT1JERVJfQU5ZLCBrbWVtX3NpemVfaW5p dCwgTlVMTCk7CiAKLS8qCi0gKiBUaGUgcmV0dXJuIHZhbHVlcyBmcm9tIGttZW1fZnJlZV8qIGFy ZSBvbmx5IHZhbGlkIG9uY2UgdGhlIHBhZ2VkYWVtb24KLSAqIGhhcyBiZWVuIGluaXRpYWxpc2Vk LCBiZWZvcmUgdGhlbiB0aGV5IHJldHVybiAwLgotICogCi0gKiBUbyBlbnN1cmUgdGhlIHJldHVy bnMgYXJlIHZhbGlkIHRoZSBjYWxsZXIgY2FuIHVzZSBhIFNZU0lOSVQgd2l0aAotICogc3Vic3lz dGVtIHNldCB0byBTSV9TVUJfS1RIUkVBRF9QQUdFIGFuZCBhbiBvcmRlciBvZiBhdCBsZWFzdAot ICogU0lfT1JERVJfU0VDT05ELgotICovCi11X2ludAota21lbV9mcmVlX3RhcmdldCh2b2lkKQot ewotCi0JcmV0dXJuICh2bV9jbnQudl9mcmVlX3RhcmdldCk7Ci19Ci0KLXVfaW50Ci1rbWVtX2Zy ZWVfbWluKHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtX2NudC52X2ZyZWVfbWluKTsKLX0KLQotdV9p bnQKLWttZW1fZnJlZV9jb3VudCh2b2lkKQotewotCi0JcmV0dXJuICh2bV9jbnQudl9mcmVlX2Nv dW50ICsgdm1fY250LnZfY2FjaGVfY291bnQpOwotfQotCi11X2ludAota21lbV9wYWdlX2NvdW50 KHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtX2NudC52X3BhZ2VfY291bnQpOwotfQotCiB1aW50NjRf dAoga21lbV9zaXplKHZvaWQpCiB7CkBAIC0xNjksMTMgKzEzMyw2IEBAIGttZW1fc2l6ZSh2b2lk KQogCXJldHVybiAoa21lbV9zaXplX3ZhbCk7CiB9CiAKLXVpbnQ2NF90Ci1rbWVtX3VzZWQodm9p ZCkKLXsKLQotCXJldHVybiAodm1lbV9zaXplKGttZW1fYXJlbmEsIFZNRU1fQUxMT0MpKTsKLX0K LQogc3RhdGljIGludAoga21lbV9zdGRfY29uc3RydWN0b3Iodm9pZCAqbWVtLCBpbnQgc2l6ZSBf X3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgaW50IGZsYWdzKQogewpJbmRleDogc3lzL2NkZGwvY29t cGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29tcGF0 L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgJKHJldmlzaW9uIDI3MDg3NSkKKysrIHN5cy9jZGRsL2Nv bXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCSh3b3JraW5nIGNvcHkpCkBAIC02NiwxNyArNjYs NiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZvaWQgKnpmc19rbWVtX2FsbG9jKHNp emVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19rbWVtX2ZyZWUodm9pZCAqYnVmLCBz aXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9pZCk7Ci11aW50NjRfdCBrbWVtX3Vz ZWQodm9pZCk7Ci11X2ludCBrbWVtX3BhZ2VfY291bnQodm9pZCk7Ci0KLS8qCi0gKiBUaGUgcmV0 dXJuIHZhbHVlcyBmcm9tIGttZW1fZnJlZV8qIGFyZSBvbmx5IHZhbGlkIG9uY2UgdGhlIHBhZ2Vk YWVtb24KLSAqIGhhcyBiZWVuIGluaXRpYWxpc2VkLCBiZWZvcmUgdGhlbiB0aGV5IHJldHVybiAw LgotICovCi11X2ludCBrbWVtX2ZyZWVfY291bnQodm9pZCk7Ci11X2ludCBrbWVtX2ZyZWVfdGFy Z2V0KHZvaWQpOwotdV9pbnQga21lbV9mcmVlX21pbih2b2lkKTsKLQoga21lbV9jYWNoZV90ICpr bWVtX2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3QgYnVmc2l6ZSwgc2l6ZV90IGFsaWdu LAogICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZvaWQgKiwgaW50KSwgdm9pZCAoKmRl c3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lkICgqcmVjbGFpbSkodm9pZCAqKSBf X3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAsIGludCBjZmxhZ3MpOwpAQCAtODgs NiArNzcsOSBAQCB2b2lkIGttZW1fcmVhcCh2b2lkKTsKIGludCBrbWVtX2RlYnVnZ2luZyh2b2lk KTsKIHZvaWQgKmNhbGxvYyhzaXplX3Qgbiwgc2l6ZV90IHMpOwogCisjZGVmaW5lCWZyZWVtZW0J CQkJKHZtX2NudC52X2ZyZWVfY291bnQgKyB2bV9jbnQudl9jYWNoZV9jb3VudCkKKyNkZWZpbmUJ bWluZnJlZQkJCQl2bV9jbnQudl9mcmVlX21pbgorI2RlZmluZQloZWFwX2FyZW5hCQkJa21lbV9h cmVuYQogI2RlZmluZQlrbWVtX2FsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChz aXplKSwgKGttZmxhZ3MpKQogI2RlZmluZQlrbWVtX3phbGxvYyhzaXplLCBrbWZsYWdzKQl6ZnNf a21lbV9hbGxvYygoc2l6ZSksIChrbWZsYWdzKSB8IE1fWkVSTykKICNkZWZpbmUJa21lbV9mcmVl KGJ1Ziwgc2l6ZSkJCXpmc19rbWVtX2ZyZWUoKGJ1ZiksIChzaXplKSkKSW5kZXg6IHN5cy9jZGRs L2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvYXJjLmMKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwko cmV2aXNpb24gMjcwODc1KQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29t bW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMTM4LDYgKzEzOCw3IEBACiAjaW5j bHVkZSA8c3lzL3NkdC5oPgogCiAjaW5jbHVkZSA8dm0vdm1fcGFnZW91dC5oPgorI2luY2x1ZGUg PG1hY2hpbmUvdm1wYXJhbS5oPgogCiAjaWZkZWYgaWxsdW1vcwogI2lmbmRlZiBfS0VSTkVMCkBA IC0yMDEsNyArMjAyLDcgQEAgaW50IHpmc19hcmNfc2hyaW5rX3NoaWZ0ID0gMDsKIGludCB6ZnNf YXJjX3BfbWluX3NoaWZ0ID0gMDsKIGludCB6ZnNfZGlzYWJsZV9kdXBfZXZpY3Rpb24gPSAwOwog dWludDY0X3QgemZzX2FyY19hdmVyYWdlX2Jsb2Nrc2l6ZSA9IDggKiAxMDI0OyAvKiA4S0IgKi8K LXVfaW50IHpmc19hcmNfZnJlZV90YXJnZXQgPSAoMSA8PCAxOSk7IC8qIGRlZmF1bHQgYmVmb3Jl IHBhZ2VkYWVtb24gaW5pdCBvbmx5ICovCit1X2ludCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gKDEg PDwgMTYpOyAvKiBkZWZhdWx0IGJlZm9yZSBwYWdlZGFlbW9uIGluaXQgb25seSAqLwogCiBzdGF0 aWMgaW50IHN5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldChTWVNDVExfSEFORExFUl9BUkdT KTsKIApAQCAtMjEwLDExICsyMTEsMTAgQEAgc3RhdGljIHZvaWQKIGFyY19mcmVlX3RhcmdldF9p bml0KHZvaWQgKnVudXNlZCBfX3VudXNlZCkKIHsKIAotCXpmc19hcmNfZnJlZV90YXJnZXQgPSBr bWVtX2ZyZWVfdGFyZ2V0KCk7CisJemZzX2FyY19mcmVlX3RhcmdldCA9ICh2bV9wYWdlb3V0X3dh a2V1cF90aHJlc2ggLyAyKSAqIDM7CiB9CiBTWVNJTklUKGFyY19mcmVlX3RhcmdldF9pbml0LCBT SV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9BTlksCiAgICAgYXJjX2ZyZWVfdGFyZ2V0X2lu aXQsIE5VTEwpOwotI2VuZGlmCiAKIFRVTkFCTEVfUVVBRCgidmZzLnpmcy5hcmNfbWV0YV9saW1p dCIsICZ6ZnNfYXJjX21ldGFfbGltaXQpOwogU1lTQ1RMX0RFQ0woX3Zmc196ZnMpOwpAQCAtMjQ1 LDkgKzI0NSw5IEBAIHN5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldChTWVNDVExfSEFORExF Ul9BUkdTCiAJaWYgKGVyciAhPSAwIHx8IHJlcS0+bmV3cHRyID09IE5VTEwpCiAJCXJldHVybiAo ZXJyKTsKIAotCWlmICh2YWwgPCBrbWVtX2ZyZWVfbWluKCkpCisJaWYgKHZhbCA8IG1pbmZyZWUp CiAJCXJldHVybiAoRUlOVkFMKTsKLQlpZiAodmFsID4ga21lbV9wYWdlX2NvdW50KCkpCisJaWYg KHZhbCA+IHZtX2NudC52X3BhZ2VfY291bnQpCiAJCXJldHVybiAoRUlOVkFMKTsKIAogCXpmc19h cmNfZnJlZV90YXJnZXQgPSB2YWw7CkBAIC0yNTQsNiArMjU0LDcgQEAgc3lzY3RsX3Zmc196ZnNf YXJjX2ZyZWVfdGFyZ2V0KFNZU0NUTF9IQU5ETEVSX0FSR1MKIAogCXJldHVybiAoMCk7CiB9Cisj ZW5kaWYKIAogLyoKICAqIE5vdGUgdGhhdCBidWZmZXJzIGNhbiBiZSBpbiBvbmUgb2YgNiBzdGF0 ZXM6CkBAIC0yNDYyLDggKzI0NjMsOCBAQCBhcmNfc2hyaW5rKHZvaWQpCiAJaWYgKGFyY19jID4g YXJjX2NfbWluKSB7CiAJCXVpbnQ2NF90IHRvX2ZyZWU7CiAKLQkJRFRSQUNFX1BST0JFMihhcmNf X3NocmluaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRfdCwKLQkJCWFyY19jX21pbik7CisJCURU UkFDRV9QUk9CRTQoYXJjX19zaHJpbmssIHVpbnQ2NF90LCBhcmNfYywgdWludDY0X3QsCisJCQlh cmNfY19taW4sIHVpbnQ2NF90LCBhcmNfcCwgdWludDY0X3QsIHRvX2ZyZWUpOwogI2lmZGVmIF9L RVJORUwKIAkJdG9fZnJlZSA9IGFyY19jID4+IGFyY19zaHJpbmtfc2hpZnQ7CiAjZWxzZQpAQCAt MjQ3OSw2ICsyNDgwLDEwIEBAIGFyY19zaHJpbmsodm9pZCkKIAkJCWFyY19jID0gTUFYKGFyY19z aXplLCBhcmNfY19taW4pOwogCQlpZiAoYXJjX3AgPiBhcmNfYykKIAkJCWFyY19wID0gKGFyY19j ID4+IDEpOworCisJCURUUkFDRV9QUk9CRTIoYXJjX19zaHJ1bmssIHVpbnQ2NF90LCBhcmNfYywg dWludDY0X3QsCisJCQlhcmNfcCk7CisKIAkJQVNTRVJUKGFyY19jID49IGFyY19jX21pbik7CiAJ CUFTU0VSVCgoaW50NjRfdClhcmNfcCA+PSAwKTsKIAl9CkBAIC0yNTAzLDE4ICsyNTA4LDEzIEBA IGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogCQlyZXR1cm4gKDEpOwogCX0KIAotCWlmIChrbWVt X2ZyZWVfY291bnQoKSA8IHpmc19hcmNfZnJlZV90YXJnZXQpIHsKLQkJRFRSQUNFX1BST0JFMihh cmNfX3JlY2xhaW1fZnJlZXRhcmdldCwgdWludDY0X3QsCi0JCSAgICBrbWVtX2ZyZWVfY291bnQo KSwgdWludDY0X3QsIHpmc19hcmNfZnJlZV90YXJnZXQpOwotCQlyZXR1cm4gKDEpOwotCX0KLQog CS8qCiAJICogQ29vcGVyYXRlIHdpdGggcGFnZWRhZW1vbiB3aGVuIGl0J3MgdGltZSBmb3IgaXQg dG8gc2NhbgogCSAqIGFuZCByZWNsYWltIHNvbWUgcGFnZXMuCiAJICovCi0JaWYgKHZtX3BhZ2lu Z19uZWVkZWQoKSkgewotCQlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX3BhZ2luZyk7CisJaWYg KGZyZWVtZW0gPCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19y ZWNsYWltX2ZyZWVtZW0sIHVpbnQ2NF90LAorCQkgICAgZnJlZW1lbSwgdWludDY0X3QsIHpmc19h cmNfZnJlZV90YXJnZXQpOwogCQlyZXR1cm4gKDEpOwogCX0KIApAQCAtMjU0NCw4ICsyNTQ0LDE5 IEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogCWlmIChhdmFpbHJtZW0gPCBzd2FwZnNfbWlu ZnJlZSArIHN3YXBmc19yZXNlcnZlICsgZXh0cmEpCiAJCXJldHVybiAoMSk7CiAKLSNpZiBkZWZp bmVkKF9faTM4NikKIAkvKgorCSAqIENoZWNrIHRoYXQgd2UgaGF2ZSBlbm91Z2ggYXZhaWxybWVt IHRoYXQgbWVtb3J5IGxvY2tpbmcgKGUuZy4sIHZpYQorCSAqIG1sb2NrKDNDKSBvciBtZW1jbnRs KDIpKSBjYW4gc3RpbGwgc3VjY2VlZC4gIChwYWdlc19wcF9tYXhpbXVtCisJICogc3RvcmVzIHRo ZSBudW1iZXIgb2YgcGFnZXMgdGhhdCBjYW5ub3QgYmUgbG9ja2VkOyB3aGVuIGF2YWlscm1lbQor CSAqIGRyb3BzIGJlbG93IHBhZ2VzX3BwX21heGltdW0sIHBhZ2UgbG9ja2luZyBtZWNoYW5pc21z IHN1Y2ggYXMKKwkgKiBwYWdlX3BwX2xvY2soKSB3aWxsIGZhaWwuKQorCSAqLworCWlmIChhdmFp bHJtZW0gPD0gcGFnZXNfcHBfbWF4aW11bSkKKwkJcmV0dXJuICgxKTsKKworI2VuZGlmCS8qIHN1 biAqLworI2lmIGRlZmluZWQoX19pMzg2KSB8fCAhZGVmaW5lZChVTUFfTURfU01BTExfQUxMT0Mp CisJLyoKIAkgKiBJZiB3ZSdyZSBvbiBhbiBpMzg2IHBsYXRmb3JtLCBpdCdzIHBvc3NpYmxlIHRo YXQgd2UnbGwgZXhoYXVzdCB0aGUKIAkgKiBrZXJuZWwgaGVhcCBzcGFjZSBiZWZvcmUgd2UgZXZl ciBydW4gb3V0IG9mIGF2YWlsYWJsZSBwaHlzaWNhbAogCSAqIG1lbW9yeS4gIE1vc3QgY2hlY2tz IG9mIHRoZSBzaXplIG9mIHRoZSBoZWFwX2FyZWEgY29tcGFyZSBhZ2FpbnN0CkBAIC0yNTU2LDI1 ICsyNTY3LDMzIEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogCSAqIGhlYXAgaXMgYWxsb2Nh dGVkLiAgKE9yLCBpbiB0aGUgY2FsY3VsYXRpb24sIGlmIGxlc3MgdGhhbiAxLzR0aCBpcwogCSAq IGZyZWUpCiAJICovCi0JaWYgKGJ0b3Aodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkp IDwKLQkgICAgKGJ0b3Aodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxM T0MpKSA+PiAyKSkKLQkJcmV0dXJuICgxKTsKLSNlbmRpZgotI2Vsc2UJLyogc3VuICovCi0jaWZk ZWYgX19pMzg2X18KLQkvKiBpMzg2IGhhcyBLVkEgbGltaXRzIHRoYXQgdGhlIHJhdyBwYWdlIGNv dW50cyBhYm92ZSBkb24ndCBjb25zaWRlciAqLwotCWlmIChrbWVtX3VzZWQoKSA+IChrbWVtX3Np emUoKSAqIDMpIC8gNCkgeworCWlmICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSA8 CisJICAgICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwgVk1FTV9BTExPQykgPj4g MikpIHsKIAkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fdXNlZCwgdWludDY0X3QsCi0JCSAg ICBrbWVtX3VzZWQoKSwgdWludDY0X3QsIChrbWVtX3NpemUoKSAqIDMpIC8gNCk7CisJCSAgICB2 bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSwgdWludDY0X3QsCisJCSAgICAodm1lbV9z aXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+PiAyKTsKIAkJcmV0dXJu ICgxKTsKIAl9CiAjZW5kaWYKKyNpZmRlZiBzdW4KKwkvKgorCSAqIElmIHppbyBkYXRhIHBhZ2Vz IGFyZSBiZWluZyBhbGxvY2F0ZWQgb3V0IG9mIGEgc2VwYXJhdGUgaGVhcCBzZWdtZW50LAorCSAq IHRoZW4gZW5mb3JjZSB0aGF0IHRoZSBzaXplIG9mIGF2YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFy ZW5hIHJlbWFpbnMKKwkgKiBhYm92ZSBhYm91dCAxLzE2dGggZnJlZS4KKwkgKgorCSAqIE5vdGU6 IFRoZSAxLzE2dGggYXJlbmEgZnJlZSByZXF1aXJlbWVudCB3YXMgcHV0IGluIHBsYWNlCisJICog dG8gYWdncmVzc2l2ZWx5IGV2aWN0IG1lbW9yeSBmcm9tIHRoZSBhcmMgaW4gb3JkZXIgdG8gYXZv aWQKKwkgKiBtZW1vcnkgZnJhZ21lbnRhdGlvbiBpc3N1ZXMuCisJICovCisJaWYgKHppb19hcmVu YSAhPSBOVUxMICYmCisJICAgIHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fRlJFRSkgPAorCSAg ICAodm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9BTExPQykgPj4gNCkpCisJCXJldHVybiAoMSk7 CiAjZW5kaWYJLyogc3VuICovCi0KLSNlbHNlCisjZWxzZQkvKiBfS0VSTkVMICovCiAJaWYgKHNw YV9nZXRfcmFuZG9tKDEwMCkgPT0gMCkKIAkJcmV0dXJuICgxKTsKLSNlbmRpZgorI2VuZGlmCS8q IF9LRVJORUwgKi8KIAlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX25vKTsKIAogCXJldHVybiAo MCk7CkBAIC0yNTgzLDcgKzI2MDIsNyBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIGV4dGVy biBrbWVtX2NhY2hlX3QJKnppb19idWZfY2FjaGVbXTsKIGV4dGVybiBrbWVtX2NhY2hlX3QJKnpp b19kYXRhX2J1Zl9jYWNoZVtdOwogCi1zdGF0aWMgdm9pZAorc3RhdGljIHZvaWQgX191c2VkCiBh cmNfa21lbV9yZWFwX25vdyhhcmNfcmVjbGFpbV9zdHJhdGVneV90IHN0cmF0KQogewogCXNpemVf dAkJCWk7CkBAIC0yNTkwLDYgKzI2MDksNyBAQCBhcmNfa21lbV9yZWFwX25vdyhhcmNfcmVjbGFp bV9zdHJhdGVneV90IHN0cmF0KQogCWttZW1fY2FjaGVfdAkJKnByZXZfY2FjaGUgPSBOVUxMOwog CWttZW1fY2FjaGVfdAkJKnByZXZfZGF0YV9jYWNoZSA9IE5VTEw7CiAKKwlEVFJBQ0VfUFJPQkUo YXJjX19rbWVtX3JlYXBfc3RhcnQpOwogI2lmZGVmIF9LRVJORUwKIAlpZiAoYXJjX21ldGFfdXNl ZCA+PSBhcmNfbWV0YV9saW1pdCkgewogCQkvKgpAQCAtMjYyNSw2ICsyNjQ1LDE2IEBAIGFyY19r bWVtX3JlYXBfbm93KGFyY19yZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJfQogCWttZW1fY2Fj aGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKIAlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9jYWNoZSk7 CisKKyNpZmRlZiBzdW4KKwkvKgorCSAqIEFzayB0aGUgdm1lbSBhcmVuYSB0byByZWNsYWltIHVu dXNlZCBtZW1vcnkgZnJvbSBpdHMKKwkgKiBxdWFudHVtIGNhY2hlcy4KKwkgKi8KKwlpZiAoemlv X2FyZW5hICE9IE5VTEwgJiYgc3RyYXQgPT0gQVJDX1JFQ0xBSU1fQUdHUikKKwkJdm1lbV9xY2Fj aGVfcmVhcCh6aW9fYXJlbmEpOworI2VuZGlmCisJRFRSQUNFX1BST0JFKGFyY19fa21lbV9yZWFw X2VuZCk7CiB9CiAKIHN0YXRpYyB2b2lkCkBAIC0yNjQyLDYgKzI2NzIsNyBAQCBhcmNfcmVjbGFp bV90aHJlYWQodm9pZCAqZHVtbXkgX191bnVzZWQpCiAKIAkJCWlmIChhcmNfbm9fZ3Jvdykgewog CQkJCWlmIChsYXN0X3JlY2xhaW0gPT0gQVJDX1JFQ0xBSU1fQ09OUykgeworCQkJCQlEVFJBQ0Vf UFJPQkUoYXJjX19yZWNsYWltX2FnZ3Jfbm9fZ3Jvdyk7CiAJCQkJCWxhc3RfcmVjbGFpbSA9IEFS Q19SRUNMQUlNX0FHR1I7CiAJCQkJfSBlbHNlIHsKIAkJCQkJbGFzdF9yZWNsYWltID0gQVJDX1JF Q0xBSU1fQ09OUzsKQEAgLTI2NDksNiArMjY4MCw3IEBAIGFyY19yZWNsYWltX3RocmVhZCh2b2lk ICpkdW1teSBfX3VudXNlZCkKIAkJCX0gZWxzZSB7CiAJCQkJYXJjX25vX2dyb3cgPSBUUlVFOwog CQkJCWxhc3RfcmVjbGFpbSA9IEFSQ19SRUNMQUlNX0FHR1I7CisJCQkJRFRSQUNFX1BST0JFKGFy Y19fcmVjbGFpbV9hZ2dyKTsKIAkJCQltZW1iYXJfcHJvZHVjZXIoKTsKIAkJCX0KIApAQCAtMjc1 Myw2ICsyNzg1LDcgQEAgYXJjX2FkYXB0KGludCBieXRlcywgYXJjX3N0YXRlX3QgKnN0YXRlKQog CSAqIGNhY2hlIHNpemUsIGluY3JlbWVudCB0aGUgdGFyZ2V0IGNhY2hlIHNpemUKIAkgKi8KIAlp ZiAoYXJjX3NpemUgPiBhcmNfYyAtICgyVUxMIDw8IFNQQV9NQVhCTE9DS1NISUZUKSkgeworCQlE VFJBQ0VfUFJPQkUxKGFyY19faW5jX2FkYXB0LCBpbnQsIGJ5dGVzKTsKIAkJYXRvbWljX2FkZF82 NCgmYXJjX2MsIChpbnQ2NF90KWJ5dGVzKTsKIAkJaWYgKGFyY19jID4gYXJjX2NfbWF4KQogCQkJ YXJjX2MgPSBhcmNfY19tYXg7CkBAIC0yNzc0LDIwICsyODA3LDYgQEAgYXJjX2V2aWN0X25lZWRl ZChhcmNfYnVmX2NvbnRlbnRzX3QgdHlwZSkKIAlpZiAodHlwZSA9PSBBUkNfQlVGQ19NRVRBREFU QSAmJiBhcmNfbWV0YV91c2VkID49IGFyY19tZXRhX2xpbWl0KQogCQlyZXR1cm4gKDEpOwogCi0j aWZkZWYgc3VuCi0jaWZkZWYgX0tFUk5FTAotCS8qCi0JICogSWYgemlvIGRhdGEgcGFnZXMgYXJl IGJlaW5nIGFsbG9jYXRlZCBvdXQgb2YgYSBzZXBhcmF0ZSBoZWFwIHNlZ21lbnQsCi0JICogdGhl biBlbmZvcmNlIHRoYXQgdGhlIHNpemUgb2YgYXZhaWxhYmxlIHZtZW0gZm9yIHRoaXMgYXJlYSBy ZW1haW5zCi0JICogYWJvdmUgYWJvdXQgMS8zMm5kIGZyZWUuCi0JICovCi0JaWYgKHR5cGUgPT0g QVJDX0JVRkNfREFUQSAmJiB6aW9fYXJlbmEgIT0gTlVMTCAmJgotCSAgICB2bWVtX3NpemUoemlv X2FyZW5hLCBWTUVNX0ZSRUUpIDwKLQkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fQUxM T0MpID4+IDUpKQotCQlyZXR1cm4gKDEpOwotI2VuZGlmCi0jZW5kaWYJLyogc3VuICovCi0KIAlp ZiAoYXJjX3JlY2xhaW1fbmVlZGVkKCkpCiAJCXJldHVybiAoMSk7CiAKQEAgLTM5NDYsMjAgKzM5 NjUsMTYgQEAgc3RhdGljIGludAogYXJjX21lbW9yeV90aHJvdHRsZSh1aW50NjRfdCByZXNlcnZl LCB1aW50NjRfdCB0eGcpCiB7CiAjaWZkZWYgX0tFUk5FTAotCXVpbnQ2NF90IGF2YWlsYWJsZV9t ZW1vcnkgPQotCSAgICBwdG9hKCh1aW50bWF4X3Qpdm1fY250LnZfZnJlZV9jb3VudCArIHZtX2Nu dC52X2NhY2hlX2NvdW50KTsKKwl1aW50NjRfdCBhdmFpbGFibGVfbWVtb3J5ID0gcHRvYihmcmVl bWVtKTsKIAlzdGF0aWMgdWludDY0X3QgcGFnZV9sb2FkID0gMDsKIAlzdGF0aWMgdWludDY0X3Qg bGFzdF90eGcgPSAwOwogCi0jaWZkZWYgc3VuCi0jaWYgZGVmaW5lZChfX2kzODYpCisjaWYgZGVm aW5lZChfX2kzODYpIHx8ICFkZWZpbmVkKFVNQV9NRF9TTUFMTF9BTExPQykKIAlhdmFpbGFibGVf bWVtb3J5ID0KLQkgICAgTUlOKGF2YWlsYWJsZV9tZW1vcnksIHZtZW1fc2l6ZShoZWFwX2FyZW5h LCBWTUVNX0ZSRUUpKTsKKwkgICAgTUlOKGF2YWlsYWJsZV9tZW1vcnksIHB0b2Iodm1lbV9zaXpl KGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkpKTsKICNlbmRpZgotI2VuZGlmCS8qIHN1biAqLwogCi0J aWYgKHZtX2NudC52X2ZyZWVfY291bnQgKyB2bV9jbnQudl9jYWNoZV9jb3VudCA+Ci0JICAgICh1 aW50NjRfdClwaHlzbWVtICogYXJjX2xvdHNmcmVlX3BlcmNlbnQgLyAxMDApCisJaWYgKGZyZWVt ZW0gPiAodWludDY0X3QpcGh5c21lbSAqIGFyY19sb3RzZnJlZV9wZXJjZW50IC8gMTAwKQogCQly ZXR1cm4gKDApOwogCiAJaWYgKHR4ZyA+IGxhc3RfdHhnKSB7CkBAIC0zOTcyLDcgKzM5ODcsNyBA QCBhcmNfbWVtb3J5X3Rocm90dGxlKHVpbnQ2NF90IHJlc2VydmUsIHVpbnQ2NF90IHR4ZwogCSAq IGNvbnRpbnVlIHRvIGxldCBwYWdlIHdyaXRlcyBvY2N1ciBhcyBxdWlja2x5IGFzIHBvc3NpYmxl LgogCSAqLwogCWlmIChjdXJwcm9jID09IHBhZ2Vwcm9jKSB7Ci0JCWlmIChwYWdlX2xvYWQgPiBh dmFpbGFibGVfbWVtb3J5IC8gNCkKKwkJaWYgKHBhZ2VfbG9hZCA+IE1BWChwdG9iKG1pbmZyZWUp LCBhdmFpbGFibGVfbWVtb3J5KSAvIDQpCiAJCQlyZXR1cm4gKFNFVF9FUlJPUihFUkVTVEFSVCkp OwogCQkvKiBOb3RlOiByZXNlcnZlIGlzIGluZmxhdGVkLCBzbyB3ZSBkZWZsYXRlICovCiAJCXBh Z2VfbG9hZCArPSByZXNlcnZlIC8gODsKQEAgLTQwMDAsOCArNDAxNSwxMCBAQCBhcmNfdGVtcHJl c2VydmVfc3BhY2UodWludDY0X3QgcmVzZXJ2ZSwgdWludDY0X3QgdAogCWludCBlcnJvcjsKIAl1 aW50NjRfdCBhbm9uX3NpemU7CiAKLQlpZiAocmVzZXJ2ZSA+IGFyY19jLzQgJiYgIWFyY19ub19n cm93KQorCWlmIChyZXNlcnZlID4gYXJjX2MvNCAmJiAhYXJjX25vX2dyb3cpIHsKIAkJYXJjX2Mg PSBNSU4oYXJjX2NfbWF4LCByZXNlcnZlICogNCk7CisJCURUUkFDRV9QUk9CRTEoYXJjX19zZXRf cmVzZXJ2ZSwgdWludDY0X3QsIGFyY19jKTsKKwl9CiAJaWYgKHJlc2VydmUgPiBhcmNfYykKIAkJ cmV0dXJuIChTRVRfRVJST1IoRU5PTUVNKSk7CiAKQEAgLTQwNTUsNiArNDA3Miw3IEBAIGFyY19s b3dtZW0odm9pZCAqYXJnIF9fdW51c2VkLCBpbnQgaG93dG8gX191bnVzZWQpCiAJbXV0ZXhfZW50 ZXIoJmFyY19sb3dtZW1fbG9jayk7CiAJbXV0ZXhfZW50ZXIoJmFyY19yZWNsYWltX3Rocl9sb2Nr KTsKIAluZWVkZnJlZSA9IDE7CisJRFRSQUNFX1BST0JFKGFyY19fbmVlZGZyZWUpOwogCWN2X3Np Z25hbCgmYXJjX3JlY2xhaW1fdGhyX2N2KTsKIAogCS8qCkluZGV4OiBzeXMvdm0vdm1fcGFnZW91 dC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIHN5cy92bS92bV9wYWdlb3V0LmMJKHJldmlzaW9uIDI3MDg3NSkK KysrIHN5cy92bS92bV9wYWdlb3V0LmMJKHdvcmtpbmcgY29weSkKQEAgLTc2LDYgKzc2LDcgQEAK IF9fRkJTRElEKCIkRnJlZUJTRCQiKTsKIAogI2luY2x1ZGUgIm9wdF92bS5oIgorI2luY2x1ZGUg Im9wdF9rZHRyYWNlLmgiCiAjaW5jbHVkZSA8c3lzL3BhcmFtLmg+CiAjaW5jbHVkZSA8c3lzL3N5 c3RtLmg+CiAjaW5jbHVkZSA8c3lzL2tlcm5lbC5oPgpAQCAtODksNiArOTAsNyBAQCBfX0ZCU0RJ RCgiJEZyZWVCU0QkIik7CiAjaW5jbHVkZSA8c3lzL3JhY2N0Lmg+CiAjaW5jbHVkZSA8c3lzL3Jl c291cmNldmFyLmg+CiAjaW5jbHVkZSA8c3lzL3NjaGVkLmg+CisjaW5jbHVkZSA8c3lzL3NkdC5o PgogI2luY2x1ZGUgPHN5cy9zaWduYWx2YXIuaD4KICNpbmNsdWRlIDxzeXMvc21wLmg+CiAjaW5j bHVkZSA8c3lzL3Zub2RlLmg+CkBAIC0xMzMsNiArMTM1LDEwIEBAIHN0YXRpYyBzdHJ1Y3Qga3By b2NfZGVzYyBwYWdlX2twID0gewogU1lTSU5JVChwYWdlZGFlbW9uLCBTSV9TVUJfS1RIUkVBRF9Q QUdFLCBTSV9PUkRFUl9TRUNPTkQsIGtwcm9jX3N0YXJ0LAogICAgICZwYWdlX2twKTsKIAorU0RU X1BST1ZJREVSX0RFRklORSh2bSk7CitTRFRfUFJPQkVfREVGSU5FKHZtLCAsICwgdm1fX2xvd21l bV9jYWNoZSk7CitTRFRfUFJPQkVfREVGSU5FKHZtLCAsICwgdm1fX2xvd21lbV9zY2FuKTsKKwog I2lmICFkZWZpbmVkKE5PX1NXQVBQSU5HKQogLyogdGhlIGtlcm5lbCBwcm9jZXNzICJ2bV9kYWVt b24iKi8KIHN0YXRpYyB2b2lkIHZtX2RhZW1vbih2b2lkKTsKQEAgLTY2Nyw2ICs2NzMsNyBAQCB2 bV9wYWdlb3V0X2dyb3dfY2FjaGUoaW50IHRyaWVzLCB2bV9wYWRkcl90IGxvdywgdgogCQkgKiBt YXkgYWNxdWlyZSBsb2NrcyBhbmQvb3Igc2xlZXAsIHNvIHRoZXkgY2FuIG9ubHkgYmUgaW52b2tl ZAogCQkgKiB3aGVuICJ0cmllcyIgaXMgZ3JlYXRlciB0aGFuIHplcm8uCiAJCSAqLworCQlTRFRf UFJPQkUwKHZtLCAsICwgdm1fX2xvd21lbV9jYWNoZSk7CiAJCUVWRU5USEFORExFUl9JTlZPS0Uo dm1fbG93bWVtLCAwKTsKIAogCQkvKgpAQCAtODk5LDcgKzkwNiw3IEBAIHZtX3BhZ2VvdXRfbWFw X2RlYWN0aXZhdGVfcGFnZXMobWFwLCBkZXNpcmVkKQogICoJcGFzcyAxIC0gTW92ZSBpbmFjdGl2 ZSB0byBjYWNoZSBvciBmcmVlCiAgKglwYXNzIDIgLSBMYXVuZGVyIGRpcnR5IHBhZ2VzCiAgKi8K LXN0YXRpYyB2b2lkCitzdGF0aWMgdm9pZCBfX3VzZWQKIHZtX3BhZ2VvdXRfc2NhbihzdHJ1Y3Qg dm1fZG9tYWluICp2bWQsIGludCBwYXNzKQogewogCXZtX3BhZ2VfdCBtLCBuZXh0OwpAQCAtOTIw LDYgKzkyNyw3IEBAIHZtX3BhZ2VvdXRfc2NhbihzdHJ1Y3Qgdm1fZG9tYWluICp2bWQsIGludCBw YXNzKQogCQkvKgogCQkgKiBEZWNyZWFzZSByZWdpc3RlcmVkIGNhY2hlIHNpemVzLgogCQkgKi8K KwkJU0RUX1BST0JFMCh2bSwgLCAsIHZtX19sb3dtZW1fc2Nhbik7CiAJCUVWRU5USEFORExFUl9J TlZPS0Uodm1fbG93bWVtLCAwKTsKIAkJLyoKIAkJICogV2UgZG8gdGhpcyBleHBsaWNpdGx5IGFm dGVyIHRoZSBjYWNoZXMgaGF2ZSBiZWVuCg== 147265 2014-09-13 05:25:58 +0000 2014-09-13 16:33:04 +0000 Patch to correct ZFS "freeze" ram contention problem (apply after Steve's latest 10-Stable patch above) patch-fix-karl text/plain 1402 karl KioqIGFyYy5jLm5vaW5pdHBhdGNoCUZyaSBTZXAgMTIgMTc6NTk6MDggMjAxNAotLS0gYXJjLmMJ RnJpIFNlcCAxMiAyMzo0OTo0MyAyMDE0CioqKioqKioqKioqKioqKgoqKiogMjEyLDIxOCAqKioq CiAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQogIHsKICAKISAJ emZzX2FyY19mcmVlX3RhcmdldCA9ICh2bV9wYWdlb3V0X3dha2V1cF90aHJlc2ggLyAyKSAqIDM7 CiAgfQogIFNZU0lOSVQoYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhSRUFEX1BBR0Us IFNJX09SREVSX0FOWSwKICAgICAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIE5VTEwpOwotLS0gMjEy LDIxOCAtLS0tCiAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQog IHsKICAKISAJemZzX2FyY19mcmVlX3RhcmdldCA9IGNudC52X2ZyZWVfdGFyZ2V0OwogIH0KICBT WVNJTklUKGFyY19mcmVlX3RhcmdldF9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRF Ul9BTlksCiAgICAgIGFyY19mcmVlX3RhcmdldF9pbml0LCBOVUxMKTsKKioqKioqKioqKioqKioq CioqKiAyNTExLDI1MTYgKioqKgotLS0gMjUxMSwyNTMyIC0tLS0KICAJdV9pbnQgZm07CiAgCiAg I2lmZGVmIF9LRVJORUwKKyAKKyAvKgorICAqIEZpcnN0IGNoZWNrIHRvIHNlZSBpZiBkaXJ0eV9k YXRhX21heCBuZWVkcyBhZGp1c3RpbmcuICBEbyBub3QgYWxsb3cKKyAgKiB0aGUgZGlydHkgZGF0 YSBhbW91bnQgcGVyIHBvb2wgdG8gZXhjZWVkIGZyZWUsIG5vbi1zd2FwcGFibGUgUkFNLgorICAq IFN1YmplY3QgdGhpcyB0byB0aGUgb3JpZ2luYWwgdGVzdCBvZiB0aGUgbWF4X21heCBsaW1pdCBh bmQgYSBtaW5pbXVtCisgICogb2YgNTEyS0IuCisgICovCisgICAgICAgICB6ZnNfZGlydHlfZGF0 YV9tYXggPSBwdG9iKGNudC52X2ZyZWVfY291bnQpIC0gcHRvYihjbnQudl9mcmVlX21pbik7Cisg ICAgICAgICBpZiAoemZzX2RpcnR5X2RhdGFfbWF4IDw9IDEgPDwgMjQpIHsKKyAgICAgICAgICAg ICAgICAgemZzX2RpcnR5X2RhdGFfbWF4ID0gMSA8PCAyNDsKKyAgICAgICAgIH0KKyAgICAgICAg IHpmc19kaXJ0eV9kYXRhX21heCA9IE1JTih6ZnNfZGlydHlfZGF0YV9tYXgsIHB0b2IocGh5c21l bSkgKgorICAgICAgICAgICAgICAgICB6ZnNfZGlydHlfZGF0YV9tYXhfcGVyY2VudCAvIDEwMCk7 CisgICAgICAgICB6ZnNfZGlydHlfZGF0YV9tYXggPSBNSU4oemZzX2RpcnR5X2RhdGFfbWF4LCB6 ZnNfZGlydHlfZGF0YV9tYXhfbWF4KTsKKyAKKyAKICAJaWYgKGFyY19zaXplIDw9IGFyY19jX21p bikgewogIAkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fbWluLCB1aW50NjRfdCwgYXJjX3Np emUsCiAgCQkgICAgdWludDY0X3QsIGFyY19jX21pbik7Cg== 147274 2014-09-13 16:33:04 +0000 2014-09-13 16:38:12 +0000 See comment -- fix potential divide-by-zero panic patch-stable10 text/plain 11044 karl SW5kZXg6IGFyYy5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGFyYy5jCShyZXZpc2lvbiAyNzE0MzUpCisrKyBh cmMuYwkod29ya2luZyBjb3B5KQpAQCAtMTM4LDYgKzEzOCw3IEBACiAjaW5jbHVkZSA8c3lzL3Nk dC5oPgogCiAjaW5jbHVkZSA8dm0vdm1fcGFnZW91dC5oPgorI2luY2x1ZGUgPG1hY2hpbmUvdm1w YXJhbS5oPgogCiAjaWZkZWYgaWxsdW1vcwogI2lmbmRlZiBfS0VSTkVMCkBAIC0xOTMsOSArMTk0 LDYgQEAKICAqLwogc3RhdGljIGJvb2xlYW5fdCBhcmNfd2FybTsKIAotLyoKLSAqIFRoZXNlIHR1 bmFibGVzIGFyZSBmb3IgcGVyZm9ybWFuY2UgYW5hbHlzaXMuCi0gKi8KIHVpbnQ2NF90IHpmc19h cmNfbWF4OwogdWludDY0X3QgemZzX2FyY19taW47CiB1aW50NjRfdCB6ZnNfYXJjX21ldGFfbGlt aXQgPSAwOwpAQCAtMjA0LDcgKzIwMiwyMSBAQAogaW50IHpmc19hcmNfcF9taW5fc2hpZnQgPSAw OwogaW50IHpmc19kaXNhYmxlX2R1cF9ldmljdGlvbiA9IDA7CiB1aW50NjRfdCB6ZnNfYXJjX2F2 ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEwMjQ7IC8qIDhLQiAqLwordV9pbnQgemZzX2FyY19mcmVl X3RhcmdldCA9ICgxIDw8IDE2KTsgLyogZGVmYXVsdCBiZWZvcmUgcGFnZWRhZW1vbiBpbml0IG9u bHkgKi8KK2ludCB6ZnNfYXJjX3JlY2xhaW1fY2FjaGVfZnJlZSA9IDE7CiAKK3N0YXRpYyBpbnQg c3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0KFNZU0NUTF9IQU5ETEVSX0FSR1MpOworCisj aWZkZWYgX0tFUk5FTAorc3RhdGljIHZvaWQKK2FyY19mcmVlX3RhcmdldF9pbml0KHZvaWQgKnVu dXNlZCBfX3VudXNlZCkKK3sKKworCXpmc19hcmNfZnJlZV90YXJnZXQgPSBjbnQudl9mcmVlX3Rh cmdldDsKK30KK1NZU0lOSVQoYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhSRUFEX1BB R0UsIFNJX09SREVSX0FOWSwKKyAgICBhcmNfZnJlZV90YXJnZXRfaW5pdCwgTlVMTCk7CisKIFRV TkFCTEVfUVVBRCgidmZzLnpmcy5hcmNfbWF4IiwgJnpmc19hcmNfbWF4KTsKIFRVTkFCTEVfUVVB RCgidmZzLnpmcy5hcmNfbWluIiwgJnpmc19hcmNfbWluKTsKIFRVTkFCTEVfUVVBRCgidmZzLnpm cy5hcmNfbWV0YV9saW1pdCIsICZ6ZnNfYXJjX21ldGFfbGltaXQpOwpAQCAtMjE3LDcgKzIyOSw0 MCBAQAogU1lTQ1RMX1VRVUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2F2ZXJhZ2VfYmxvY2tz aXplLCBDVExGTEFHX1JEVFVOLAogICAgICZ6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCAwLAog ICAgICJBUkMgYXZlcmFnZSBibG9ja3NpemUiKTsKK1NZU0NUTF9JTlQoX3Zmc196ZnMsIE9JRF9B VVRPLCBhcmNfcmVjbGFpbV9jYWNoZV9mcmVlLCBDVExGTEFHX1JXVFVOLAorICAgICZ6ZnNfYXJj X3JlY2xhaW1fY2FjaGVfZnJlZSwgMCwKKyAgICAiQVJDIHRyZWF0cyBjYWNoZWQgcGFnZXMgYXMg ZnJlZSBibG9ja3NpemUiKTsKKy8qCisgKiBXZSBkb24ndCBoYXZlIGEgdHVuYWJsZSBmb3IgYXJj X2ZyZWVfdGFyZ2V0IGR1ZSB0byB0aGUgZGVwZW5kZW5jeSBvbgorICogcGFnZWRhZW1vbiBpbml0 aWFsaXNhdGlvbi4KKyAqLworU1lTQ1RMX1BST0MoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfZnJl ZV90YXJnZXQsCisgICAgQ1RMVFlQRV9VSU5UIHwgQ1RMRkxBR19NUFNBRkUgfCBDVExGTEFHX1JX LCAwLCBzaXplb2YodV9pbnQpLAorICAgIHN5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldCwg IklVIiwKKyAgICAiRGVzaXJlZCBudW1iZXIgb2YgZnJlZSBwYWdlcyBiZWxvdyB3aGljaCBBUkMg dHJpZ2dlcnMgcmVjbGFpbSIpOwogCitzdGF0aWMgaW50CitzeXNjdGxfdmZzX3pmc19hcmNfZnJl ZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUykKK3sKKwl1X2ludCB2YWw7CisJaW50IGVycjsK KworCXZhbCA9IHpmc19hcmNfZnJlZV90YXJnZXQ7CisJZXJyID0gc3lzY3RsX2hhbmRsZV9pbnQo b2lkcCwgJnZhbCwgMCwgcmVxKTsKKwlpZiAoZXJyICE9IDAgfHwgcmVxLT5uZXdwdHIgPT0gTlVM TCkKKwkJcmV0dXJuIChlcnIpOworCisJaWYgKHZhbCA8IG1pbmZyZWUpCisJCXJldHVybiAoRUlO VkFMKTsKKwlpZiAodmFsID4gY250LnZfcGFnZV9jb3VudCkKKwkJcmV0dXJuIChFSU5WQUwpOwor CisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZhbDsKKworCXJldHVybiAoMCk7Cit9CisjZW5kaWYK KwogLyoKICAqIE5vdGUgdGhhdCBidWZmZXJzIGNhbiBiZSBpbiBvbmUgb2YgNiBzdGF0ZXM6CiAg KglBUkNfYW5vbgktIGFub255bW91cyAoZGlzY3Vzc2VkIGJlbG93KQpAQCAtMjQyMSw2ICsyNDY2 LDcgQEAKIHZvaWQKIGFyY19zaHJpbmsodm9pZCkKIHsKKwogCWlmIChhcmNfYyA+IGFyY19jX21p bikgewogCQl1aW50NjRfdCB0b19mcmVlOwogCkBAIC0yNDI5LDYgKzI0NzUsOSBAQAogI2Vsc2UK IAkJdG9fZnJlZSA9IGFyY19jID4+IGFyY19zaHJpbmtfc2hpZnQ7CiAjZW5kaWYKKwkJRFRSQUNF X1BST0JFNChhcmNfX3NocmluaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRfdCwKKwkJCWFyY19j X21pbiwgdWludDY0X3QsIGFyY19wLCB1aW50NjRfdCwgdG9fZnJlZSk7CisKIAkJaWYgKGFyY19j ID4gYXJjX2NfbWluICsgdG9fZnJlZSkKIAkJCWF0b21pY19hZGRfNjQoJmFyY19jLCAtdG9fZnJl ZSk7CiAJCWVsc2UKQEAgLTI0MzksMTIgKzI0ODgsMTkgQEAKIAkJCWFyY19jID0gTUFYKGFyY19z aXplLCBhcmNfY19taW4pOwogCQlpZiAoYXJjX3AgPiBhcmNfYykKIAkJCWFyY19wID0gKGFyY19j ID4+IDEpOworCisJCURUUkFDRV9QUk9CRTIoYXJjX19zaHJ1bmssIHVpbnQ2NF90LCBhcmNfYywg dWludDY0X3QsCisJCQlhcmNfcCk7CisKIAkJQVNTRVJUKGFyY19jID49IGFyY19jX21pbik7CiAJ CUFTU0VSVCgoaW50NjRfdClhcmNfcCA+PSAwKTsKIAl9CiAKLQlpZiAoYXJjX3NpemUgPiBhcmNf YykKKwlpZiAoYXJjX3NpemUgPiBhcmNfYykgeworCQlEVFJBQ0VfUFJPQkUyKGFyY19fc2hyaW5r X2FkanVzdCwgdWludDY0X3QsIGFyY19zaXplLAorCQkJdWludDY0X3QsIGFyY19jKTsKIAkJYXJj X2FkanVzdCgpOworCX0KIH0KIAogc3RhdGljIGludCBuZWVkZnJlZSA9IDA7CkBAIC0yNDUyLDE4 ICsyNTA4LDUxIEBACiBzdGF0aWMgaW50CiBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIHsKKwl1 X2ludCBmbTsKIAogI2lmZGVmIF9LRVJORUwKIAotCWlmIChuZWVkZnJlZSkKKy8qCisgKiBGaXJz dCBjaGVjayB0byBzZWUgaWYgZGlydHlfZGF0YV9tYXggbmVlZHMgYWRqdXN0aW5nLiAgRG8gbm90 IGFsbG93CisgKiB0aGUgZGlydHkgZGF0YSBhbW91bnQgcGVyIHBvb2wgdG8gZXhjZWVkIGZyZWUs IG5vbi1zd2FwcGFibGUgUkFNLgorICogU3ViamVjdCB0aGlzIHRvIHRoZSBvcmlnaW5hbCB0ZXN0 IG9mIHRoZSBtYXhfbWF4IGxpbWl0IGFuZCBhIG1pbmltdW0KKyAqIG9mIDE2TUIuCisgKi8KKyAg ICAgICAgemZzX2RpcnR5X2RhdGFfbWF4ID0gcHRvYihjbnQudl9mcmVlX2NvdW50KSAtIHB0b2Io Y250LnZfZnJlZV9taW4pOworICAgICAgICBpZiAoemZzX2RpcnR5X2RhdGFfbWF4IDw9IDEgPDwg MjQpIHsKKyAgICAgICAgICAgICAgICB6ZnNfZGlydHlfZGF0YV9tYXggPSAxIDw8IDI0OworICAg ICAgICB9CisgICAgICAgIHpmc19kaXJ0eV9kYXRhX21heCA9IE1JTih6ZnNfZGlydHlfZGF0YV9t YXgsIHB0b2IocGh5c21lbSkgKgorICAgICAgICAgICAgICAgIHpmc19kaXJ0eV9kYXRhX21heF9w ZXJjZW50IC8gMTAwKTsKKyAgICAgICAgemZzX2RpcnR5X2RhdGFfbWF4ID0gTUlOKHpmc19kaXJ0 eV9kYXRhX21heCwgemZzX2RpcnR5X2RhdGFfbWF4X21heCk7CisKKworCWlmIChhcmNfc2l6ZSA8 PSBhcmNfY19taW4pIHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fbWluLCB1aW50NjRf dCwgYXJjX3NpemUsCisJCSAgICB1aW50NjRfdCwgYXJjX2NfbWluKTsKKwkJcmV0dXJuICgwKTsK Kwl9CisKKwlpZiAobmVlZGZyZWUpIHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9uZWVk ZnJlZSk7CiAJCXJldHVybiAoMSk7CisJfQogCiAJLyoKIAkgKiBDb29wZXJhdGUgd2l0aCBwYWdl ZGFlbW9uIHdoZW4gaXQncyB0aW1lIGZvciBpdCB0byBzY2FuCiAJICogYW5kIHJlY2xhaW0gc29t ZSBwYWdlcy4KIAkgKi8KLQlpZiAodm1fcGFnaW5nX25lZWRlZCgpKQorCWlmICh6ZnNfYXJjX3Jl Y2xhaW1fY2FjaGVfZnJlZSA9PSAwKQorCQlmbSA9IGNudC52X2ZyZWVfY291bnQ7CisJZWxzZQor CQlmbSA9IGZyZWVtZW07CisKKwlpZiAoZm0gPCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KSB7CisJCURU UkFDRV9QUk9CRTMoYXJjX19yZWNsYWltX2ZyZWVtZW0sIHVpbnQ2NF90LAorCQkgICAgZm0sIHVp bnQ2NF90LCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0LAorCQkgICAgaW50LCB6ZnNfYXJjX3JlY2xhaW1f Y2FjaGVfZnJlZSk7CiAJCXJldHVybiAoMSk7CisJfQogCiAjaWZkZWYgc3VuCiAJLyoKQEAgLTI0 OTEsOCArMjU4MCwxOSBAQAogCWlmIChhdmFpbHJtZW0gPCBzd2FwZnNfbWluZnJlZSArIHN3YXBm c19yZXNlcnZlICsgZXh0cmEpCiAJCXJldHVybiAoMSk7CiAKLSNpZiBkZWZpbmVkKF9faTM4NikK IAkvKgorCSAqIENoZWNrIHRoYXQgd2UgaGF2ZSBlbm91Z2ggYXZhaWxybWVtIHRoYXQgbWVtb3J5 IGxvY2tpbmcgKGUuZy4sIHZpYQorCSAqIG1sb2NrKDNDKSBvciBtZW1jbnRsKDIpKSBjYW4gc3Rp bGwgc3VjY2VlZC4gIChwYWdlc19wcF9tYXhpbXVtCisJICogc3RvcmVzIHRoZSBudW1iZXIgb2Yg cGFnZXMgdGhhdCBjYW5ub3QgYmUgbG9ja2VkOyB3aGVuIGF2YWlscm1lbQorCSAqIGRyb3BzIGJl bG93IHBhZ2VzX3BwX21heGltdW0sIHBhZ2UgbG9ja2luZyBtZWNoYW5pc21zIHN1Y2ggYXMKKwkg KiBwYWdlX3BwX2xvY2soKSB3aWxsIGZhaWwuKQorCSAqLworCWlmIChhdmFpbHJtZW0gPD0gcGFn ZXNfcHBfbWF4aW11bSkKKwkJcmV0dXJuICgxKTsKKworI2VuZGlmCS8qIHN1biAqLworI2lmIGRl ZmluZWQoX19pMzg2KSB8fCAhZGVmaW5lZChVTUFfTURfU01BTExfQUxMT0MpCisJLyoKIAkgKiBJ ZiB3ZSdyZSBvbiBhbiBpMzg2IHBsYXRmb3JtLCBpdCdzIHBvc3NpYmxlIHRoYXQgd2UnbGwgZXho YXVzdCB0aGUKIAkgKiBrZXJuZWwgaGVhcCBzcGFjZSBiZWZvcmUgd2UgZXZlciBydW4gb3V0IG9m IGF2YWlsYWJsZSBwaHlzaWNhbAogCSAqIG1lbW9yeS4gIE1vc3QgY2hlY2tzIG9mIHRoZSBzaXpl IG9mIHRoZSBoZWFwX2FyZWEgY29tcGFyZSBhZ2FpbnN0CkBAIC0yNTAzLDMyICsyNjAzLDQ5IEBA CiAJICogaGVhcCBpcyBhbGxvY2F0ZWQuICAoT3IsIGluIHRoZSBjYWxjdWxhdGlvbiwgaWYgbGVz cyB0aGFuIDEvNHRoIGlzCiAJICogZnJlZSkKIAkgKi8KLQlpZiAoYnRvcCh2bWVtX3NpemUoaGVh cF9hcmVuYSwgVk1FTV9GUkVFKSkgPAotCSAgICAoYnRvcCh2bWVtX3NpemUoaGVhcF9hcmVuYSwg Vk1FTV9GUkVFIHwgVk1FTV9BTExPQykpID4+IDIpKQorCWlmICh2bWVtX3NpemUoaGVhcF9hcmVu YSwgVk1FTV9GUkVFKSA8CisJICAgICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwg Vk1FTV9BTExPQykgPj4gMikpIHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fdXNlZCwg dWludDY0X3QsCisJCSAgICB2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSwgdWludDY0 X3QsCisJCSAgICAodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0Mp KSA+PiAyKTsKIAkJcmV0dXJuICgxKTsKKwl9CiAjZW5kaWYKLSNlbHNlCS8qICFzdW4gKi8KLQlp ZiAoa21lbV91c2VkKCkgPiAoa21lbV9zaXplKCkgKiAzKSAvIDQpCisjaWZkZWYgc3VuCisJLyoK KwkgKiBJZiB6aW8gZGF0YSBwYWdlcyBhcmUgYmVpbmcgYWxsb2NhdGVkIG91dCBvZiBhIHNlcGFy YXRlIGhlYXAgc2VnbWVudCwKKwkgKiB0aGVuIGVuZm9yY2UgdGhhdCB0aGUgc2l6ZSBvZiBhdmFp bGFibGUgdm1lbSBmb3IgdGhpcyBhcmVuYSByZW1haW5zCisJICogYWJvdmUgYWJvdXQgMS8xNnRo IGZyZWUuCisJICoKKwkgKiBOb3RlOiBUaGUgMS8xNnRoIGFyZW5hIGZyZWUgcmVxdWlyZW1lbnQg d2FzIHB1dCBpbiBwbGFjZQorCSAqIHRvIGFnZ3Jlc3NpdmVseSBldmljdCBtZW1vcnkgZnJvbSB0 aGUgYXJjIGluIG9yZGVyIHRvIGF2b2lkCisJICogbWVtb3J5IGZyYWdtZW50YXRpb24gaXNzdWVz LgorCSAqLworCWlmICh6aW9fYXJlbmEgIT0gTlVMTCAmJgorCSAgICB2bWVtX3NpemUoemlvX2Fy ZW5hLCBWTUVNX0ZSRUUpIDwKKwkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fQUxMT0Mp ID4+IDQpKQogCQlyZXR1cm4gKDEpOwogI2VuZGlmCS8qIHN1biAqLwotCi0jZWxzZQorI2Vsc2UJ LyogX0tFUk5FTCAqLwogCWlmIChzcGFfZ2V0X3JhbmRvbSgxMDApID09IDApCiAJCXJldHVybiAo MSk7Ci0jZW5kaWYKKyNlbmRpZgkvKiBfS0VSTkVMICovCisJRFRSQUNFX1BST0JFKGFyY19fcmVj bGFpbV9ubyk7CisKIAlyZXR1cm4gKDApOwogfQogCiBleHRlcm4ga21lbV9jYWNoZV90CSp6aW9f YnVmX2NhY2hlW107CiBleHRlcm4ga21lbV9jYWNoZV90CSp6aW9fZGF0YV9idWZfY2FjaGVbXTsK IAotc3RhdGljIHZvaWQKK3N0YXRpYyB2b2lkIF9fdXNlZAogYXJjX2ttZW1fcmVhcF9ub3coYXJj X3JlY2xhaW1fc3RyYXRlZ3lfdCBzdHJhdCkKIHsKIAlzaXplX3QJCQlpOwogCWttZW1fY2FjaGVf dAkJKnByZXZfY2FjaGUgPSBOVUxMOwogCWttZW1fY2FjaGVfdAkJKnByZXZfZGF0YV9jYWNoZSA9 IE5VTEw7CiAKKwlEVFJBQ0VfUFJPQkUoYXJjX19rbWVtX3JlYXBfc3RhcnQpOwogI2lmZGVmIF9L RVJORUwKIAlpZiAoYXJjX21ldGFfdXNlZCA+PSBhcmNfbWV0YV9saW1pdCkgewogCQkvKgpAQCAt MjU2NCw2ICsyNjgxLDE2IEBACiAJfQogCWttZW1fY2FjaGVfcmVhcF9ub3coYnVmX2NhY2hlKTsK IAlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9jYWNoZSk7CisKKyNpZmRlZiBzdW4KKwkvKgorCSAq IEFzayB0aGUgdm1lbSBhcmVhbmEgdG8gcmVjbGFpbSB1bnVzZWQgbWVtb3J5IGZyb20gaXRzCisJ ICogcXVhbnR1bSBjYWNoZXMuCisJICovCisJaWYgKHppb19hcmVuYSAhPSBOVUxMICYmIHN0cmF0 ID09IEFSQ19SRUNMQUlNX0FHR1IpCisJCXZtZW1fcWNhY2hlX3JlYXAoemlvX2FyZW5hKTsKKyNl bmRpZgorCURUUkFDRV9QUk9CRShhcmNfX2ttZW1fcmVhcF9lbmQpOwogfQogCiBzdGF0aWMgdm9p ZApAQCAtMjU4MSw2ICsyNzA4LDcgQEAKIAogCQkJaWYgKGFyY19ub19ncm93KSB7CiAJCQkJaWYg KGxhc3RfcmVjbGFpbSA9PSBBUkNfUkVDTEFJTV9DT05TKSB7CisJCQkJCURUUkFDRV9QUk9CRShh cmNfX3JlY2xhaW1fYWdncl9ub19ncm93KTsKIAkJCQkJbGFzdF9yZWNsYWltID0gQVJDX1JFQ0xB SU1fQUdHUjsKIAkJCQl9IGVsc2UgewogCQkJCQlsYXN0X3JlY2xhaW0gPSBBUkNfUkVDTEFJTV9D T05TOwpAQCAtMjU4OCw2ICsyNzE2LDcgQEAKIAkJCX0gZWxzZSB7CiAJCQkJYXJjX25vX2dyb3cg PSBUUlVFOwogCQkJCWxhc3RfcmVjbGFpbSA9IEFSQ19SRUNMQUlNX0FHR1I7CisJCQkJRFRSQUNF X1BST0JFKGFyY19fcmVjbGFpbV9hZ2dyKTsKIAkJCQltZW1iYXJfcHJvZHVjZXIoKTsKIAkJCX0K IApAQCAtMjYwMiw2ICsyNzMxLDcgQEAKIAkJCQkgKi8KIAkJCQlhcmNfbm9fZ3JvdyA9IFRSVUU7 CiAJCQkJbGFzdF9yZWNsYWltID0gQVJDX1JFQ0xBSU1fQUdHUjsKKwkJCQlEVFJBQ0VfUFJPQkUo YXJjX19yZWNsYWltX2FnZ3JfbmVlZGZyZWUpOwogCQkJfQogCQkJYXJjX2ttZW1fcmVhcF9ub3co bGFzdF9yZWNsYWltKTsKIAkJCWFyY193YXJtID0gQl9UUlVFOwpAQCAtMjYxOCw2ICsyNzQ4LDcg QEAKICNpZmRlZiBfS0VSTkVMCiAJCWlmIChuZWVkZnJlZSkgewogCQkJbmVlZGZyZWUgPSAwOwor CQkJRFRSQUNFX1BST0JFKGFyY19fY2xlYXJfbmVlZGZyZWUpOwogCQkJd2FrZXVwKCZuZWVkZnJl ZSk7CiAJCX0KICNlbmRpZgpAQCAtMjY5Miw2ICsyODIzLDcgQEAKIAkgKiBjYWNoZSBzaXplLCBp bmNyZW1lbnQgdGhlIHRhcmdldCBjYWNoZSBzaXplCiAJICovCiAJaWYgKGFyY19zaXplID4gYXJj X2MgLSAoMlVMTCA8PCBTUEFfTUFYQkxPQ0tTSElGVCkpIHsKKwkJRFRSQUNFX1BST0JFMShhcmNf X2luY19hZGFwdCwgaW50LCBieXRlcyk7CiAJCWF0b21pY19hZGRfNjQoJmFyY19jLCAoaW50NjRf dClieXRlcyk7CiAJCWlmIChhcmNfYyA+IGFyY19jX21heCkKIAkJCWFyY19jID0gYXJjX2NfbWF4 OwpAQCAtMjcxMywyMCArMjg0NSw2IEBACiAJaWYgKHR5cGUgPT0gQVJDX0JVRkNfTUVUQURBVEEg JiYgYXJjX21ldGFfdXNlZCA+PSBhcmNfbWV0YV9saW1pdCkKIAkJcmV0dXJuICgxKTsKIAotI2lm ZGVmIHN1bgotI2lmZGVmIF9LRVJORUwKLQkvKgotCSAqIElmIHppbyBkYXRhIHBhZ2VzIGFyZSBi ZWluZyBhbGxvY2F0ZWQgb3V0IG9mIGEgc2VwYXJhdGUgaGVhcCBzZWdtZW50LAotCSAqIHRoZW4g ZW5mb3JjZSB0aGF0IHRoZSBzaXplIG9mIGF2YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFyZWEgcmVt YWlucwotCSAqIGFib3ZlIGFib3V0IDEvMzJuZCBmcmVlLgotCSAqLwotCWlmICh0eXBlID09IEFS Q19CVUZDX0RBVEEgJiYgemlvX2FyZW5hICE9IE5VTEwgJiYKLQkgICAgdm1lbV9zaXplKHppb19h cmVuYSwgVk1FTV9GUkVFKSA8Ci0JICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0FMTE9D KSA+PiA1KSkKLQkJcmV0dXJuICgxKTsKLSNlbmRpZgotI2VuZGlmCS8qIHN1biAqLwotCiAJaWYg KGFyY19yZWNsYWltX25lZWRlZCgpKQogCQlyZXR1cm4gKDEpOwogCkBAIC0zODg1LDIwICs0MDAz LDE2IEBACiBhcmNfbWVtb3J5X3Rocm90dGxlKHVpbnQ2NF90IHJlc2VydmUsIHVpbnQ2NF90IHR4 ZykKIHsKICNpZmRlZiBfS0VSTkVMCi0JdWludDY0X3QgYXZhaWxhYmxlX21lbW9yeSA9Ci0JICAg IHB0b2EoKHVpbnRtYXhfdCljbnQudl9mcmVlX2NvdW50ICsgY250LnZfY2FjaGVfY291bnQpOwor CXVpbnQ2NF90IGF2YWlsYWJsZV9tZW1vcnkgPSBwdG9iKGZyZWVtZW0pOwogCXN0YXRpYyB1aW50 NjRfdCBwYWdlX2xvYWQgPSAwOwogCXN0YXRpYyB1aW50NjRfdCBsYXN0X3R4ZyA9IDA7CiAKLSNp ZmRlZiBzdW4KLSNpZiBkZWZpbmVkKF9faTM4NikKKyNpZiBkZWZpbmVkKF9faTM4NikgfHwgIWRl ZmluZWQoVU1BX01EX1NNQUxMX0FMTE9DKQogCWF2YWlsYWJsZV9tZW1vcnkgPQotCSAgICBNSU4o YXZhaWxhYmxlX21lbW9yeSwgdm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkpOworCSAg ICBNSU4oYXZhaWxhYmxlX21lbW9yeSwgcHRvYih2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9G UkVFKSkpOwogI2VuZGlmCi0jZW5kaWYJLyogc3VuICovCiAKLQlpZiAoY250LnZfZnJlZV9jb3Vu dCArIGNudC52X2NhY2hlX2NvdW50ID4KLQkgICAgKHVpbnQ2NF90KXBoeXNtZW0gKiBhcmNfbG90 c2ZyZWVfcGVyY2VudCAvIDEwMCkKKwlpZiAoZnJlZW1lbSA+ICh1aW50NjRfdClwaHlzbWVtICog YXJjX2xvdHNmcmVlX3BlcmNlbnQgLyAxMDApCiAJCXJldHVybiAoMCk7CiAKIAlpZiAodHhnID4g bGFzdF90eGcpIHsKQEAgLTM5MTEsNyArNDAyNSw3IEBACiAJICogY29udGludWUgdG8gbGV0IHBh Z2Ugd3JpdGVzIG9jY3VyIGFzIHF1aWNrbHkgYXMgcG9zc2libGUuCiAJICovCiAJaWYgKGN1cnBy b2MgPT0gcGFnZXByb2MpIHsKLQkJaWYgKHBhZ2VfbG9hZCA+IGF2YWlsYWJsZV9tZW1vcnkgLyA0 KQorCQlpZiAocGFnZV9sb2FkID4gTUFYKHB0b2IobWluZnJlZSksIGF2YWlsYWJsZV9tZW1vcnkp IC8gNCkKIAkJCXJldHVybiAoU0VUX0VSUk9SKEVSRVNUQVJUKSk7CiAJCS8qIE5vdGU6IHJlc2Vy dmUgaXMgaW5mbGF0ZWQsIHNvIHdlIGRlZmxhdGUgKi8KIAkJcGFnZV9sb2FkICs9IHJlc2VydmUg LyA4OwpAQCAtMzkzOSw4ICs0MDUzLDEwIEBACiAJaW50IGVycm9yOwogCXVpbnQ2NF90IGFub25f c2l6ZTsKIAotCWlmIChyZXNlcnZlID4gYXJjX2MvNCAmJiAhYXJjX25vX2dyb3cpCisJaWYgKHJl c2VydmUgPiBhcmNfYy80ICYmICFhcmNfbm9fZ3JvdykgewogCQlhcmNfYyA9IE1JTihhcmNfY19t YXgsIHJlc2VydmUgKiA0KTsKKwkJRFRSQUNFX1BST0JFMShhcmNfX3NldF9yZXNlcnZlLCB1aW50 NjRfdCwgYXJjX2MpOworCX0KIAlpZiAocmVzZXJ2ZSA+IGFyY19jKQogCQlyZXR1cm4gKFNFVF9F UlJPUihFTk9NRU0pKTsKIApAQCAtMzk5NCw2ICs0MTEwLDcgQEAKIAltdXRleF9lbnRlcigmYXJj X2xvd21lbV9sb2NrKTsKIAltdXRleF9lbnRlcigmYXJjX3JlY2xhaW1fdGhyX2xvY2spOwogCW5l ZWRmcmVlID0gMTsKKwlEVFJBQ0VfUFJPQkUoYXJjX19uZWVkZnJlZSk7CiAJY3Zfc2lnbmFsKCZh cmNfcmVjbGFpbV90aHJfY3YpOwogCiAJLyoKSW5kZXg6IGRtdV90eC5jCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IGRtdV90eC5jCShyZXZpc2lvbiAyNzE0MzUpCisrKyBkbXVfdHguYwkod29ya2luZyBjb3B5KQpA QCAtMTA2Myw2ICsxMDYzLDE0IEBACiAJQVNTRVJUM1UoZGlydHksIDwsIHpmc19kaXJ0eV9kYXRh X21heCk7CiAKIAlub3cgPSBnZXRocnRpbWUoKTsKKwkvKgorCSAqIEJlY2F1c2Ugb2YgZHluYW1p YyBkaXJ0eV9kYXRhX21heCBzaXppbmcgaW4gYXJjLmMsIGl0IGlzIHBvc3NpYmxlCisJICogZm9y IGl0IHRvIGJlIGV4YWN0bHkgZXF1YWwgdG8gZGlydHkuICBQcmV2ZW50IGRpdmlkZS1ieS16ZXJv IHBhbmljCisJICogaW4gdGhlIHVubGlrZWx5IGV2ZW50IHRoYXQgaGFwcGVucyB0byBiZSB0aGUg Y2FzZS4KKwkgKi8KKwlpZiAhKHpmc19kaXJ0eV9kYXRhX21heCAtIGRpcnR5KQorCQl6ZnNfZGly dHlfZGF0YV9tYXgrKzsKKwl9CiAJbWluX3R4X3RpbWUgPSB6ZnNfZGVsYXlfc2NhbGUgKgogCSAg ICAoZGlydHkgLSBkZWxheV9taW5fYnl0ZXMpIC8gKHpmc19kaXJ0eV9kYXRhX21heCAtIGRpcnR5 KTsKIAlpZiAobm93ID4gdHgtPnR4X3N0YXJ0ICsgbWluX3R4X3RpbWUpCg== 147275 2014-09-13 16:38:12 +0000 2014-09-13 16:41:50 +0000 Replace previous patch -- picked up wrong copy (extra parenthesis) patch-fixed-stable text/plain 11040 karl SW5kZXg6IGFyYy5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGFyYy5jCShyZXZpc2lvbiAyNzE0MzUpCisrKyBh cmMuYwkod29ya2luZyBjb3B5KQpAQCAtMTM4LDYgKzEzOCw3IEBACiAjaW5jbHVkZSA8c3lzL3Nk dC5oPgogCiAjaW5jbHVkZSA8dm0vdm1fcGFnZW91dC5oPgorI2luY2x1ZGUgPG1hY2hpbmUvdm1w YXJhbS5oPgogCiAjaWZkZWYgaWxsdW1vcwogI2lmbmRlZiBfS0VSTkVMCkBAIC0xOTMsOSArMTk0 LDYgQEAKICAqLwogc3RhdGljIGJvb2xlYW5fdCBhcmNfd2FybTsKIAotLyoKLSAqIFRoZXNlIHR1 bmFibGVzIGFyZSBmb3IgcGVyZm9ybWFuY2UgYW5hbHlzaXMuCi0gKi8KIHVpbnQ2NF90IHpmc19h cmNfbWF4OwogdWludDY0X3QgemZzX2FyY19taW47CiB1aW50NjRfdCB6ZnNfYXJjX21ldGFfbGlt aXQgPSAwOwpAQCAtMjA0LDcgKzIwMiwyMSBAQAogaW50IHpmc19hcmNfcF9taW5fc2hpZnQgPSAw OwogaW50IHpmc19kaXNhYmxlX2R1cF9ldmljdGlvbiA9IDA7CiB1aW50NjRfdCB6ZnNfYXJjX2F2 ZXJhZ2VfYmxvY2tzaXplID0gOCAqIDEwMjQ7IC8qIDhLQiAqLwordV9pbnQgemZzX2FyY19mcmVl X3RhcmdldCA9ICgxIDw8IDE2KTsgLyogZGVmYXVsdCBiZWZvcmUgcGFnZWRhZW1vbiBpbml0IG9u bHkgKi8KK2ludCB6ZnNfYXJjX3JlY2xhaW1fY2FjaGVfZnJlZSA9IDE7CiAKK3N0YXRpYyBpbnQg c3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0KFNZU0NUTF9IQU5ETEVSX0FSR1MpOworCisj aWZkZWYgX0tFUk5FTAorc3RhdGljIHZvaWQKK2FyY19mcmVlX3RhcmdldF9pbml0KHZvaWQgKnVu dXNlZCBfX3VudXNlZCkKK3sKKworCXpmc19hcmNfZnJlZV90YXJnZXQgPSBjbnQudl9mcmVlX3Rh cmdldDsKK30KK1NZU0lOSVQoYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhSRUFEX1BB R0UsIFNJX09SREVSX0FOWSwKKyAgICBhcmNfZnJlZV90YXJnZXRfaW5pdCwgTlVMTCk7CisKIFRV TkFCTEVfUVVBRCgidmZzLnpmcy5hcmNfbWF4IiwgJnpmc19hcmNfbWF4KTsKIFRVTkFCTEVfUVVB RCgidmZzLnpmcy5hcmNfbWluIiwgJnpmc19hcmNfbWluKTsKIFRVTkFCTEVfUVVBRCgidmZzLnpm cy5hcmNfbWV0YV9saW1pdCIsICZ6ZnNfYXJjX21ldGFfbGltaXQpOwpAQCAtMjE3LDcgKzIyOSw0 MCBAQAogU1lTQ1RMX1VRVUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2F2ZXJhZ2VfYmxvY2tz aXplLCBDVExGTEFHX1JEVFVOLAogICAgICZ6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCAwLAog ICAgICJBUkMgYXZlcmFnZSBibG9ja3NpemUiKTsKK1NZU0NUTF9JTlQoX3Zmc196ZnMsIE9JRF9B VVRPLCBhcmNfcmVjbGFpbV9jYWNoZV9mcmVlLCBDVExGTEFHX1JXVFVOLAorICAgICZ6ZnNfYXJj X3JlY2xhaW1fY2FjaGVfZnJlZSwgMCwKKyAgICAiQVJDIHRyZWF0cyBjYWNoZWQgcGFnZXMgYXMg ZnJlZSBibG9ja3NpemUiKTsKKy8qCisgKiBXZSBkb24ndCBoYXZlIGEgdHVuYWJsZSBmb3IgYXJj X2ZyZWVfdGFyZ2V0IGR1ZSB0byB0aGUgZGVwZW5kZW5jeSBvbgorICogcGFnZWRhZW1vbiBpbml0 aWFsaXNhdGlvbi4KKyAqLworU1lTQ1RMX1BST0MoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfZnJl ZV90YXJnZXQsCisgICAgQ1RMVFlQRV9VSU5UIHwgQ1RMRkxBR19NUFNBRkUgfCBDVExGTEFHX1JX LCAwLCBzaXplb2YodV9pbnQpLAorICAgIHN5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldCwg IklVIiwKKyAgICAiRGVzaXJlZCBudW1iZXIgb2YgZnJlZSBwYWdlcyBiZWxvdyB3aGljaCBBUkMg dHJpZ2dlcnMgcmVjbGFpbSIpOwogCitzdGF0aWMgaW50CitzeXNjdGxfdmZzX3pmc19hcmNfZnJl ZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUykKK3sKKwl1X2ludCB2YWw7CisJaW50IGVycjsK KworCXZhbCA9IHpmc19hcmNfZnJlZV90YXJnZXQ7CisJZXJyID0gc3lzY3RsX2hhbmRsZV9pbnQo b2lkcCwgJnZhbCwgMCwgcmVxKTsKKwlpZiAoZXJyICE9IDAgfHwgcmVxLT5uZXdwdHIgPT0gTlVM TCkKKwkJcmV0dXJuIChlcnIpOworCisJaWYgKHZhbCA8IG1pbmZyZWUpCisJCXJldHVybiAoRUlO VkFMKTsKKwlpZiAodmFsID4gY250LnZfcGFnZV9jb3VudCkKKwkJcmV0dXJuIChFSU5WQUwpOwor CisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZhbDsKKworCXJldHVybiAoMCk7Cit9CisjZW5kaWYK KwogLyoKICAqIE5vdGUgdGhhdCBidWZmZXJzIGNhbiBiZSBpbiBvbmUgb2YgNiBzdGF0ZXM6CiAg KglBUkNfYW5vbgktIGFub255bW91cyAoZGlzY3Vzc2VkIGJlbG93KQpAQCAtMjQyMSw2ICsyNDY2 LDcgQEAKIHZvaWQKIGFyY19zaHJpbmsodm9pZCkKIHsKKwogCWlmIChhcmNfYyA+IGFyY19jX21p bikgewogCQl1aW50NjRfdCB0b19mcmVlOwogCkBAIC0yNDI5LDYgKzI0NzUsOSBAQAogI2Vsc2UK IAkJdG9fZnJlZSA9IGFyY19jID4+IGFyY19zaHJpbmtfc2hpZnQ7CiAjZW5kaWYKKwkJRFRSQUNF X1BST0JFNChhcmNfX3NocmluaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRfdCwKKwkJCWFyY19j X21pbiwgdWludDY0X3QsIGFyY19wLCB1aW50NjRfdCwgdG9fZnJlZSk7CisKIAkJaWYgKGFyY19j ID4gYXJjX2NfbWluICsgdG9fZnJlZSkKIAkJCWF0b21pY19hZGRfNjQoJmFyY19jLCAtdG9fZnJl ZSk7CiAJCWVsc2UKQEAgLTI0MzksMTIgKzI0ODgsMTkgQEAKIAkJCWFyY19jID0gTUFYKGFyY19z aXplLCBhcmNfY19taW4pOwogCQlpZiAoYXJjX3AgPiBhcmNfYykKIAkJCWFyY19wID0gKGFyY19j ID4+IDEpOworCisJCURUUkFDRV9QUk9CRTIoYXJjX19zaHJ1bmssIHVpbnQ2NF90LCBhcmNfYywg dWludDY0X3QsCisJCQlhcmNfcCk7CisKIAkJQVNTRVJUKGFyY19jID49IGFyY19jX21pbik7CiAJ CUFTU0VSVCgoaW50NjRfdClhcmNfcCA+PSAwKTsKIAl9CiAKLQlpZiAoYXJjX3NpemUgPiBhcmNf YykKKwlpZiAoYXJjX3NpemUgPiBhcmNfYykgeworCQlEVFJBQ0VfUFJPQkUyKGFyY19fc2hyaW5r X2FkanVzdCwgdWludDY0X3QsIGFyY19zaXplLAorCQkJdWludDY0X3QsIGFyY19jKTsKIAkJYXJj X2FkanVzdCgpOworCX0KIH0KIAogc3RhdGljIGludCBuZWVkZnJlZSA9IDA7CkBAIC0yNDUyLDE4 ICsyNTA4LDUxIEBACiBzdGF0aWMgaW50CiBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIHsKKwl1 X2ludCBmbTsKIAogI2lmZGVmIF9LRVJORUwKIAotCWlmIChuZWVkZnJlZSkKKy8qCisgKiBGaXJz dCBjaGVjayB0byBzZWUgaWYgZGlydHlfZGF0YV9tYXggbmVlZHMgYWRqdXN0aW5nLiAgRG8gbm90 IGFsbG93CisgKiB0aGUgZGlydHkgZGF0YSBhbW91bnQgcGVyIHBvb2wgdG8gZXhjZWVkIGZyZWUs IG5vbi1zd2FwcGFibGUgUkFNLgorICogU3ViamVjdCB0aGlzIHRvIHRoZSBvcmlnaW5hbCB0ZXN0 IG9mIHRoZSBtYXhfbWF4IGxpbWl0IGFuZCBhIG1pbmltdW0KKyAqIG9mIDE2TUIuCisgKi8KKyAg ICAgICAgemZzX2RpcnR5X2RhdGFfbWF4ID0gcHRvYihjbnQudl9mcmVlX2NvdW50KSAtIHB0b2Io Y250LnZfZnJlZV9taW4pOworICAgICAgICBpZiAoemZzX2RpcnR5X2RhdGFfbWF4IDw9IDEgPDwg MjQpIHsKKyAgICAgICAgICAgICAgICB6ZnNfZGlydHlfZGF0YV9tYXggPSAxIDw8IDI0OworICAg ICAgICB9CisgICAgICAgIHpmc19kaXJ0eV9kYXRhX21heCA9IE1JTih6ZnNfZGlydHlfZGF0YV9t YXgsIHB0b2IocGh5c21lbSkgKgorICAgICAgICAgICAgICAgIHpmc19kaXJ0eV9kYXRhX21heF9w ZXJjZW50IC8gMTAwKTsKKyAgICAgICAgemZzX2RpcnR5X2RhdGFfbWF4ID0gTUlOKHpmc19kaXJ0 eV9kYXRhX21heCwgemZzX2RpcnR5X2RhdGFfbWF4X21heCk7CisKKworCWlmIChhcmNfc2l6ZSA8 PSBhcmNfY19taW4pIHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fbWluLCB1aW50NjRf dCwgYXJjX3NpemUsCisJCSAgICB1aW50NjRfdCwgYXJjX2NfbWluKTsKKwkJcmV0dXJuICgwKTsK Kwl9CisKKwlpZiAobmVlZGZyZWUpIHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9uZWVk ZnJlZSk7CiAJCXJldHVybiAoMSk7CisJfQogCiAJLyoKIAkgKiBDb29wZXJhdGUgd2l0aCBwYWdl ZGFlbW9uIHdoZW4gaXQncyB0aW1lIGZvciBpdCB0byBzY2FuCiAJICogYW5kIHJlY2xhaW0gc29t ZSBwYWdlcy4KIAkgKi8KLQlpZiAodm1fcGFnaW5nX25lZWRlZCgpKQorCWlmICh6ZnNfYXJjX3Jl Y2xhaW1fY2FjaGVfZnJlZSA9PSAwKQorCQlmbSA9IGNudC52X2ZyZWVfY291bnQ7CisJZWxzZQor CQlmbSA9IGZyZWVtZW07CisKKwlpZiAoZm0gPCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KSB7CisJCURU UkFDRV9QUk9CRTMoYXJjX19yZWNsYWltX2ZyZWVtZW0sIHVpbnQ2NF90LAorCQkgICAgZm0sIHVp bnQ2NF90LCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0LAorCQkgICAgaW50LCB6ZnNfYXJjX3JlY2xhaW1f Y2FjaGVfZnJlZSk7CiAJCXJldHVybiAoMSk7CisJfQogCiAjaWZkZWYgc3VuCiAJLyoKQEAgLTI0 OTEsOCArMjU4MCwxOSBAQAogCWlmIChhdmFpbHJtZW0gPCBzd2FwZnNfbWluZnJlZSArIHN3YXBm c19yZXNlcnZlICsgZXh0cmEpCiAJCXJldHVybiAoMSk7CiAKLSNpZiBkZWZpbmVkKF9faTM4NikK IAkvKgorCSAqIENoZWNrIHRoYXQgd2UgaGF2ZSBlbm91Z2ggYXZhaWxybWVtIHRoYXQgbWVtb3J5 IGxvY2tpbmcgKGUuZy4sIHZpYQorCSAqIG1sb2NrKDNDKSBvciBtZW1jbnRsKDIpKSBjYW4gc3Rp bGwgc3VjY2VlZC4gIChwYWdlc19wcF9tYXhpbXVtCisJICogc3RvcmVzIHRoZSBudW1iZXIgb2Yg cGFnZXMgdGhhdCBjYW5ub3QgYmUgbG9ja2VkOyB3aGVuIGF2YWlscm1lbQorCSAqIGRyb3BzIGJl bG93IHBhZ2VzX3BwX21heGltdW0sIHBhZ2UgbG9ja2luZyBtZWNoYW5pc21zIHN1Y2ggYXMKKwkg KiBwYWdlX3BwX2xvY2soKSB3aWxsIGZhaWwuKQorCSAqLworCWlmIChhdmFpbHJtZW0gPD0gcGFn ZXNfcHBfbWF4aW11bSkKKwkJcmV0dXJuICgxKTsKKworI2VuZGlmCS8qIHN1biAqLworI2lmIGRl ZmluZWQoX19pMzg2KSB8fCAhZGVmaW5lZChVTUFfTURfU01BTExfQUxMT0MpCisJLyoKIAkgKiBJ ZiB3ZSdyZSBvbiBhbiBpMzg2IHBsYXRmb3JtLCBpdCdzIHBvc3NpYmxlIHRoYXQgd2UnbGwgZXho YXVzdCB0aGUKIAkgKiBrZXJuZWwgaGVhcCBzcGFjZSBiZWZvcmUgd2UgZXZlciBydW4gb3V0IG9m IGF2YWlsYWJsZSBwaHlzaWNhbAogCSAqIG1lbW9yeS4gIE1vc3QgY2hlY2tzIG9mIHRoZSBzaXpl IG9mIHRoZSBoZWFwX2FyZWEgY29tcGFyZSBhZ2FpbnN0CkBAIC0yNTAzLDMyICsyNjAzLDQ5IEBA CiAJICogaGVhcCBpcyBhbGxvY2F0ZWQuICAoT3IsIGluIHRoZSBjYWxjdWxhdGlvbiwgaWYgbGVz cyB0aGFuIDEvNHRoIGlzCiAJICogZnJlZSkKIAkgKi8KLQlpZiAoYnRvcCh2bWVtX3NpemUoaGVh cF9hcmVuYSwgVk1FTV9GUkVFKSkgPAotCSAgICAoYnRvcCh2bWVtX3NpemUoaGVhcF9hcmVuYSwg Vk1FTV9GUkVFIHwgVk1FTV9BTExPQykpID4+IDIpKQorCWlmICh2bWVtX3NpemUoaGVhcF9hcmVu YSwgVk1FTV9GUkVFKSA8CisJICAgICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwg Vk1FTV9BTExPQykgPj4gMikpIHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fdXNlZCwg dWludDY0X3QsCisJCSAgICB2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSwgdWludDY0 X3QsCisJCSAgICAodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0Mp KSA+PiAyKTsKIAkJcmV0dXJuICgxKTsKKwl9CiAjZW5kaWYKLSNlbHNlCS8qICFzdW4gKi8KLQlp ZiAoa21lbV91c2VkKCkgPiAoa21lbV9zaXplKCkgKiAzKSAvIDQpCisjaWZkZWYgc3VuCisJLyoK KwkgKiBJZiB6aW8gZGF0YSBwYWdlcyBhcmUgYmVpbmcgYWxsb2NhdGVkIG91dCBvZiBhIHNlcGFy YXRlIGhlYXAgc2VnbWVudCwKKwkgKiB0aGVuIGVuZm9yY2UgdGhhdCB0aGUgc2l6ZSBvZiBhdmFp bGFibGUgdm1lbSBmb3IgdGhpcyBhcmVuYSByZW1haW5zCisJICogYWJvdmUgYWJvdXQgMS8xNnRo IGZyZWUuCisJICoKKwkgKiBOb3RlOiBUaGUgMS8xNnRoIGFyZW5hIGZyZWUgcmVxdWlyZW1lbnQg d2FzIHB1dCBpbiBwbGFjZQorCSAqIHRvIGFnZ3Jlc3NpdmVseSBldmljdCBtZW1vcnkgZnJvbSB0 aGUgYXJjIGluIG9yZGVyIHRvIGF2b2lkCisJICogbWVtb3J5IGZyYWdtZW50YXRpb24gaXNzdWVz LgorCSAqLworCWlmICh6aW9fYXJlbmEgIT0gTlVMTCAmJgorCSAgICB2bWVtX3NpemUoemlvX2Fy ZW5hLCBWTUVNX0ZSRUUpIDwKKwkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fQUxMT0Mp ID4+IDQpKQogCQlyZXR1cm4gKDEpOwogI2VuZGlmCS8qIHN1biAqLwotCi0jZWxzZQorI2Vsc2UJ LyogX0tFUk5FTCAqLwogCWlmIChzcGFfZ2V0X3JhbmRvbSgxMDApID09IDApCiAJCXJldHVybiAo MSk7Ci0jZW5kaWYKKyNlbmRpZgkvKiBfS0VSTkVMICovCisJRFRSQUNFX1BST0JFKGFyY19fcmVj bGFpbV9ubyk7CisKIAlyZXR1cm4gKDApOwogfQogCiBleHRlcm4ga21lbV9jYWNoZV90CSp6aW9f YnVmX2NhY2hlW107CiBleHRlcm4ga21lbV9jYWNoZV90CSp6aW9fZGF0YV9idWZfY2FjaGVbXTsK IAotc3RhdGljIHZvaWQKK3N0YXRpYyB2b2lkIF9fdXNlZAogYXJjX2ttZW1fcmVhcF9ub3coYXJj X3JlY2xhaW1fc3RyYXRlZ3lfdCBzdHJhdCkKIHsKIAlzaXplX3QJCQlpOwogCWttZW1fY2FjaGVf dAkJKnByZXZfY2FjaGUgPSBOVUxMOwogCWttZW1fY2FjaGVfdAkJKnByZXZfZGF0YV9jYWNoZSA9 IE5VTEw7CiAKKwlEVFJBQ0VfUFJPQkUoYXJjX19rbWVtX3JlYXBfc3RhcnQpOwogI2lmZGVmIF9L RVJORUwKIAlpZiAoYXJjX21ldGFfdXNlZCA+PSBhcmNfbWV0YV9saW1pdCkgewogCQkvKgpAQCAt MjU2NCw2ICsyNjgxLDE2IEBACiAJfQogCWttZW1fY2FjaGVfcmVhcF9ub3coYnVmX2NhY2hlKTsK IAlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9jYWNoZSk7CisKKyNpZmRlZiBzdW4KKwkvKgorCSAq IEFzayB0aGUgdm1lbSBhcmVhbmEgdG8gcmVjbGFpbSB1bnVzZWQgbWVtb3J5IGZyb20gaXRzCisJ ICogcXVhbnR1bSBjYWNoZXMuCisJICovCisJaWYgKHppb19hcmVuYSAhPSBOVUxMICYmIHN0cmF0 ID09IEFSQ19SRUNMQUlNX0FHR1IpCisJCXZtZW1fcWNhY2hlX3JlYXAoemlvX2FyZW5hKTsKKyNl bmRpZgorCURUUkFDRV9QUk9CRShhcmNfX2ttZW1fcmVhcF9lbmQpOwogfQogCiBzdGF0aWMgdm9p ZApAQCAtMjU4MSw2ICsyNzA4LDcgQEAKIAogCQkJaWYgKGFyY19ub19ncm93KSB7CiAJCQkJaWYg KGxhc3RfcmVjbGFpbSA9PSBBUkNfUkVDTEFJTV9DT05TKSB7CisJCQkJCURUUkFDRV9QUk9CRShh cmNfX3JlY2xhaW1fYWdncl9ub19ncm93KTsKIAkJCQkJbGFzdF9yZWNsYWltID0gQVJDX1JFQ0xB SU1fQUdHUjsKIAkJCQl9IGVsc2UgewogCQkJCQlsYXN0X3JlY2xhaW0gPSBBUkNfUkVDTEFJTV9D T05TOwpAQCAtMjU4OCw2ICsyNzE2LDcgQEAKIAkJCX0gZWxzZSB7CiAJCQkJYXJjX25vX2dyb3cg PSBUUlVFOwogCQkJCWxhc3RfcmVjbGFpbSA9IEFSQ19SRUNMQUlNX0FHR1I7CisJCQkJRFRSQUNF X1BST0JFKGFyY19fcmVjbGFpbV9hZ2dyKTsKIAkJCQltZW1iYXJfcHJvZHVjZXIoKTsKIAkJCX0K IApAQCAtMjYwMiw2ICsyNzMxLDcgQEAKIAkJCQkgKi8KIAkJCQlhcmNfbm9fZ3JvdyA9IFRSVUU7 CiAJCQkJbGFzdF9yZWNsYWltID0gQVJDX1JFQ0xBSU1fQUdHUjsKKwkJCQlEVFJBQ0VfUFJPQkUo YXJjX19yZWNsYWltX2FnZ3JfbmVlZGZyZWUpOwogCQkJfQogCQkJYXJjX2ttZW1fcmVhcF9ub3co bGFzdF9yZWNsYWltKTsKIAkJCWFyY193YXJtID0gQl9UUlVFOwpAQCAtMjYxOCw2ICsyNzQ4LDcg QEAKICNpZmRlZiBfS0VSTkVMCiAJCWlmIChuZWVkZnJlZSkgewogCQkJbmVlZGZyZWUgPSAwOwor CQkJRFRSQUNFX1BST0JFKGFyY19fY2xlYXJfbmVlZGZyZWUpOwogCQkJd2FrZXVwKCZuZWVkZnJl ZSk7CiAJCX0KICNlbmRpZgpAQCAtMjY5Miw2ICsyODIzLDcgQEAKIAkgKiBjYWNoZSBzaXplLCBp bmNyZW1lbnQgdGhlIHRhcmdldCBjYWNoZSBzaXplCiAJICovCiAJaWYgKGFyY19zaXplID4gYXJj X2MgLSAoMlVMTCA8PCBTUEFfTUFYQkxPQ0tTSElGVCkpIHsKKwkJRFRSQUNFX1BST0JFMShhcmNf X2luY19hZGFwdCwgaW50LCBieXRlcyk7CiAJCWF0b21pY19hZGRfNjQoJmFyY19jLCAoaW50NjRf dClieXRlcyk7CiAJCWlmIChhcmNfYyA+IGFyY19jX21heCkKIAkJCWFyY19jID0gYXJjX2NfbWF4 OwpAQCAtMjcxMywyMCArMjg0NSw2IEBACiAJaWYgKHR5cGUgPT0gQVJDX0JVRkNfTUVUQURBVEEg JiYgYXJjX21ldGFfdXNlZCA+PSBhcmNfbWV0YV9saW1pdCkKIAkJcmV0dXJuICgxKTsKIAotI2lm ZGVmIHN1bgotI2lmZGVmIF9LRVJORUwKLQkvKgotCSAqIElmIHppbyBkYXRhIHBhZ2VzIGFyZSBi ZWluZyBhbGxvY2F0ZWQgb3V0IG9mIGEgc2VwYXJhdGUgaGVhcCBzZWdtZW50LAotCSAqIHRoZW4g ZW5mb3JjZSB0aGF0IHRoZSBzaXplIG9mIGF2YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFyZWEgcmVt YWlucwotCSAqIGFib3ZlIGFib3V0IDEvMzJuZCBmcmVlLgotCSAqLwotCWlmICh0eXBlID09IEFS Q19CVUZDX0RBVEEgJiYgemlvX2FyZW5hICE9IE5VTEwgJiYKLQkgICAgdm1lbV9zaXplKHppb19h cmVuYSwgVk1FTV9GUkVFKSA8Ci0JICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0FMTE9D KSA+PiA1KSkKLQkJcmV0dXJuICgxKTsKLSNlbmRpZgotI2VuZGlmCS8qIHN1biAqLwotCiAJaWYg KGFyY19yZWNsYWltX25lZWRlZCgpKQogCQlyZXR1cm4gKDEpOwogCkBAIC0zODg1LDIwICs0MDAz LDE2IEBACiBhcmNfbWVtb3J5X3Rocm90dGxlKHVpbnQ2NF90IHJlc2VydmUsIHVpbnQ2NF90IHR4 ZykKIHsKICNpZmRlZiBfS0VSTkVMCi0JdWludDY0X3QgYXZhaWxhYmxlX21lbW9yeSA9Ci0JICAg IHB0b2EoKHVpbnRtYXhfdCljbnQudl9mcmVlX2NvdW50ICsgY250LnZfY2FjaGVfY291bnQpOwor CXVpbnQ2NF90IGF2YWlsYWJsZV9tZW1vcnkgPSBwdG9iKGZyZWVtZW0pOwogCXN0YXRpYyB1aW50 NjRfdCBwYWdlX2xvYWQgPSAwOwogCXN0YXRpYyB1aW50NjRfdCBsYXN0X3R4ZyA9IDA7CiAKLSNp ZmRlZiBzdW4KLSNpZiBkZWZpbmVkKF9faTM4NikKKyNpZiBkZWZpbmVkKF9faTM4NikgfHwgIWRl ZmluZWQoVU1BX01EX1NNQUxMX0FMTE9DKQogCWF2YWlsYWJsZV9tZW1vcnkgPQotCSAgICBNSU4o YXZhaWxhYmxlX21lbW9yeSwgdm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkpOworCSAg ICBNSU4oYXZhaWxhYmxlX21lbW9yeSwgcHRvYih2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9G UkVFKSkpOwogI2VuZGlmCi0jZW5kaWYJLyogc3VuICovCiAKLQlpZiAoY250LnZfZnJlZV9jb3Vu dCArIGNudC52X2NhY2hlX2NvdW50ID4KLQkgICAgKHVpbnQ2NF90KXBoeXNtZW0gKiBhcmNfbG90 c2ZyZWVfcGVyY2VudCAvIDEwMCkKKwlpZiAoZnJlZW1lbSA+ICh1aW50NjRfdClwaHlzbWVtICog YXJjX2xvdHNmcmVlX3BlcmNlbnQgLyAxMDApCiAJCXJldHVybiAoMCk7CiAKIAlpZiAodHhnID4g bGFzdF90eGcpIHsKQEAgLTM5MTEsNyArNDAyNSw3IEBACiAJICogY29udGludWUgdG8gbGV0IHBh Z2Ugd3JpdGVzIG9jY3VyIGFzIHF1aWNrbHkgYXMgcG9zc2libGUuCiAJICovCiAJaWYgKGN1cnBy b2MgPT0gcGFnZXByb2MpIHsKLQkJaWYgKHBhZ2VfbG9hZCA+IGF2YWlsYWJsZV9tZW1vcnkgLyA0 KQorCQlpZiAocGFnZV9sb2FkID4gTUFYKHB0b2IobWluZnJlZSksIGF2YWlsYWJsZV9tZW1vcnkp IC8gNCkKIAkJCXJldHVybiAoU0VUX0VSUk9SKEVSRVNUQVJUKSk7CiAJCS8qIE5vdGU6IHJlc2Vy dmUgaXMgaW5mbGF0ZWQsIHNvIHdlIGRlZmxhdGUgKi8KIAkJcGFnZV9sb2FkICs9IHJlc2VydmUg LyA4OwpAQCAtMzkzOSw4ICs0MDUzLDEwIEBACiAJaW50IGVycm9yOwogCXVpbnQ2NF90IGFub25f c2l6ZTsKIAotCWlmIChyZXNlcnZlID4gYXJjX2MvNCAmJiAhYXJjX25vX2dyb3cpCisJaWYgKHJl c2VydmUgPiBhcmNfYy80ICYmICFhcmNfbm9fZ3JvdykgewogCQlhcmNfYyA9IE1JTihhcmNfY19t YXgsIHJlc2VydmUgKiA0KTsKKwkJRFRSQUNFX1BST0JFMShhcmNfX3NldF9yZXNlcnZlLCB1aW50 NjRfdCwgYXJjX2MpOworCX0KIAlpZiAocmVzZXJ2ZSA+IGFyY19jKQogCQlyZXR1cm4gKFNFVF9F UlJPUihFTk9NRU0pKTsKIApAQCAtMzk5NCw2ICs0MTEwLDcgQEAKIAltdXRleF9lbnRlcigmYXJj X2xvd21lbV9sb2NrKTsKIAltdXRleF9lbnRlcigmYXJjX3JlY2xhaW1fdGhyX2xvY2spOwogCW5l ZWRmcmVlID0gMTsKKwlEVFJBQ0VfUFJPQkUoYXJjX19uZWVkZnJlZSk7CiAJY3Zfc2lnbmFsKCZh cmNfcmVjbGFpbV90aHJfY3YpOwogCiAJLyoKSW5kZXg6IGRtdV90eC5jCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IGRtdV90eC5jCShyZXZpc2lvbiAyNzE0MzUpCisrKyBkbXVfdHguYwkod29ya2luZyBjb3B5KQpA QCAtMTA2Myw2ICsxMDYzLDEzIEBACiAJQVNTRVJUM1UoZGlydHksIDwsIHpmc19kaXJ0eV9kYXRh X21heCk7CiAKIAlub3cgPSBnZXRocnRpbWUoKTsKKwkvKgorCSAqIEJlY2F1c2Ugb2YgZHluYW1p YyBkaXJ0eV9kYXRhX21heCBzaXppbmcgaW4gYXJjLmMsIGl0IGlzIHBvc3NpYmxlCisJICogZm9y IGl0IHRvIGJlIGV4YWN0bHkgZXF1YWwgdG8gZGlydHkuICBQcmV2ZW50IGRpdmlkZS1ieS16ZXJv IHBhbmljCisJICogaW4gdGhlIHVubGlrZWx5IGV2ZW50IHRoYXQgaGFwcGVucyB0byBiZSB0aGUg Y2FzZS4KKwkgKi8KKwlpZiAhKHpmc19kaXJ0eV9kYXRhX21heCAtIGRpcnR5KQorCQl6ZnNfZGly dHlfZGF0YV9tYXgrKzsKIAltaW5fdHhfdGltZSA9IHpmc19kZWxheV9zY2FsZSAqCiAJICAgIChk aXJ0eSAtIGRlbGF5X21pbl9ieXRlcykgLyAoemZzX2RpcnR5X2RhdGFfbWF4IC0gZGlydHkpOwog CWlmIChub3cgPiB0eC0+dHhfc3RhcnQgKyBtaW5fdHhfdGltZSkK 147276 2014-09-13 16:41:50 +0000 2014-09-13 20:34:10 +0000 Argh - didn't include all of Steve's other changes -- yet another try :-) patch-stable-10 text/plain 15604 karl SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MTQzNSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTMzLDEzICsx MzMsNiBAQAogCXJldHVybiAoa21lbV9zaXplX3ZhbCk7CiB9CiAKLXVpbnQ2NF90Ci1rbWVtX3Vz ZWQodm9pZCkKLXsKLQotCXJldHVybiAodm1lbV9zaXplKGttZW1fYXJlbmEsIFZNRU1fQUxMT0Mp KTsKLX0KLQogc3RhdGljIGludAoga21lbV9zdGRfY29uc3RydWN0b3Iodm9pZCAqbWVtLCBpbnQg c2l6ZSBfX3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgaW50IGZsYWdzKQogewpJbmRleDogc3lzL2Nk ZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwv Y29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgJKHJldmlzaW9uIDI3MTQzNSkKKysrIHN5cy9j ZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCSh3b3JraW5nIGNvcHkpCkBAIC02Niw3 ICs2Niw2IEBACiB2b2lkICp6ZnNfa21lbV9hbGxvYyhzaXplX3Qgc2l6ZSwgaW50IGttZmxhZ3Mp Owogdm9pZCB6ZnNfa21lbV9mcmVlKHZvaWQgKmJ1Ziwgc2l6ZV90IHNpemUpOwogdWludDY0X3Qg a21lbV9zaXplKHZvaWQpOwotdWludDY0X3Qga21lbV91c2VkKHZvaWQpOwoga21lbV9jYWNoZV90 ICprbWVtX2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3QgYnVmc2l6ZSwgc2l6ZV90IGFs aWduLAogICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZvaWQgKiwgaW50KSwgdm9pZCAo KmRlc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lkICgqcmVjbGFpbSkodm9pZCAq KSBfX3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAsIGludCBjZmxhZ3MpOwpAQCAt NzgsNiArNzcsOSBAQAogaW50IGttZW1fZGVidWdnaW5nKHZvaWQpOwogdm9pZCAqY2FsbG9jKHNp emVfdCBuLCBzaXplX3Qgcyk7CiAKKyNkZWZpbmUJZnJlZW1lbQkJCQkoY250LnZfZnJlZV9jb3Vu dCArIGNudC52X2NhY2hlX2NvdW50KQorI2RlZmluZQltaW5mcmVlCQkJCWNudC52X2ZyZWVfbWlu CisjZGVmaW5lCWhlYXBfYXJlbmEJCQlrbWVtX2FyZW5hCiAjZGVmaW5lCWttZW1fYWxsb2Moc2l6 ZSwga21mbGFncykJemZzX2ttZW1fYWxsb2MoKHNpemUpLCAoa21mbGFncykpCiAjZGVmaW5lCWtt ZW1femFsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChzaXplKSwgKGttZmxhZ3Mp IHwgTV9aRVJPKQogI2RlZmluZQlrbWVtX2ZyZWUoYnVmLCBzaXplKQkJemZzX2ttZW1fZnJlZSgo YnVmKSwgKHNpemUpKQpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29t bW9uL2ZzL3pmcy9hcmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xh cmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzE0MzUpCisrKyBzeXMvY2Rk bC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3b3JraW5nIGNv cHkpCkBAIC0xMzgsNiArMTM4LDcgQEAKICNpbmNsdWRlIDxzeXMvc2R0Lmg+CiAKICNpbmNsdWRl IDx2bS92bV9wYWdlb3V0Lmg+CisjaW5jbHVkZSA8bWFjaGluZS92bXBhcmFtLmg+CiAKICNpZmRl ZiBpbGx1bW9zCiAjaWZuZGVmIF9LRVJORUwKQEAgLTE5Myw5ICsxOTQsNiBAQAogICovCiBzdGF0 aWMgYm9vbGVhbl90IGFyY193YXJtOwogCi0vKgotICogVGhlc2UgdHVuYWJsZXMgYXJlIGZvciBw ZXJmb3JtYW5jZSBhbmFseXNpcy4KLSAqLwogdWludDY0X3QgemZzX2FyY19tYXg7CiB1aW50NjRf dCB6ZnNfYXJjX21pbjsKIHVpbnQ2NF90IHpmc19hcmNfbWV0YV9saW1pdCA9IDA7CkBAIC0yMDQs NyArMjAyLDIxIEBACiBpbnQgemZzX2FyY19wX21pbl9zaGlmdCA9IDA7CiBpbnQgemZzX2Rpc2Fi bGVfZHVwX2V2aWN0aW9uID0gMDsKIHVpbnQ2NF90IHpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUg PSA4ICogMTAyNDsgLyogOEtCICovCit1X2ludCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gKDEgPDwg MTYpOyAvKiBkZWZhdWx0IGJlZm9yZSBwYWdlZGFlbW9uIGluaXQgb25seSAqLworaW50IHpmc19h cmNfcmVjbGFpbV9jYWNoZV9mcmVlID0gMTsKIAorc3RhdGljIGludCBzeXNjdGxfdmZzX3pmc19h cmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CisKKyNpZmRlZiBfS0VSTkVMCitz dGF0aWMgdm9pZAorYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQor eworCisJemZzX2FyY19mcmVlX3RhcmdldCA9IGNudC52X2ZyZWVfdGFyZ2V0OworfQorU1lTSU5J VChhcmNfZnJlZV90YXJnZXRfaW5pdCwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfQU5Z LAorICAgIGFyY19mcmVlX3RhcmdldF9pbml0LCBOVUxMKTsKKwogVFVOQUJMRV9RVUFEKCJ2ZnMu emZzLmFyY19tYXgiLCAmemZzX2FyY19tYXgpOwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19t aW4iLCAmemZzX2FyY19taW4pOwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19tZXRhX2xpbWl0 IiwgJnpmc19hcmNfbWV0YV9saW1pdCk7CkBAIC0yMTcsNyArMjI5LDQwIEBACiBTWVNDVExfVVFV QUQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfYXZlcmFnZV9ibG9ja3NpemUsIENUTEZMQUdfUkRU VU4sCiAgICAgJnpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUsIDAsCiAgICAgIkFSQyBhdmVyYWdl IGJsb2Nrc2l6ZSIpOworU1lTQ1RMX0lOVChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19yZWNsYWlt X2NhY2hlX2ZyZWUsIENUTEZMQUdfUldUVU4sCisgICAgJnpmc19hcmNfcmVjbGFpbV9jYWNoZV9m cmVlLCAwLAorICAgICJBUkMgdHJlYXRzIGNhY2hlZCBwYWdlcyBhcyBmcmVlIGJsb2Nrc2l6ZSIp OworLyoKKyAqIFdlIGRvbid0IGhhdmUgYSB0dW5hYmxlIGZvciBhcmNfZnJlZV90YXJnZXQgZHVl IHRvIHRoZSBkZXBlbmRlbmN5IG9uCisgKiBwYWdlZGFlbW9uIGluaXRpYWxpc2F0aW9uLgorICov CitTWVNDVExfUFJPQyhfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19mcmVlX3RhcmdldCwKKyAgICBD VExUWVBFX1VJTlQgfCBDVExGTEFHX01QU0FGRSB8IENUTEZMQUdfUlcsIDAsIHNpemVvZih1X2lu dCksCisgICAgc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0LCAiSVUiLAorICAgICJEZXNp cmVkIG51bWJlciBvZiBmcmVlIHBhZ2VzIGJlbG93IHdoaWNoIEFSQyB0cmlnZ2VycyByZWNsYWlt Iik7CiAKK3N0YXRpYyBpbnQKK3N5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldChTWVNDVExf SEFORExFUl9BUkdTKQoreworCXVfaW50IHZhbDsKKwlpbnQgZXJyOworCisJdmFsID0gemZzX2Fy Y19mcmVlX3RhcmdldDsKKwllcnIgPSBzeXNjdGxfaGFuZGxlX2ludChvaWRwLCAmdmFsLCAwLCBy ZXEpOworCWlmIChlcnIgIT0gMCB8fCByZXEtPm5ld3B0ciA9PSBOVUxMKQorCQlyZXR1cm4gKGVy cik7CisKKwlpZiAodmFsIDwgbWluZnJlZSkKKwkJcmV0dXJuIChFSU5WQUwpOworCWlmICh2YWwg PiBjbnQudl9wYWdlX2NvdW50KQorCQlyZXR1cm4gKEVJTlZBTCk7CisKKwl6ZnNfYXJjX2ZyZWVf dGFyZ2V0ID0gdmFsOworCisJcmV0dXJuICgwKTsKK30KKyNlbmRpZgorCiAvKgogICogTm90ZSB0 aGF0IGJ1ZmZlcnMgY2FuIGJlIGluIG9uZSBvZiA2IHN0YXRlczoKICAqCUFSQ19hbm9uCS0gYW5v bnltb3VzIChkaXNjdXNzZWQgYmVsb3cpCkBAIC0yNDIxLDYgKzI0NjYsNyBAQAogdm9pZAogYXJj X3Nocmluayh2b2lkKQogeworCiAJaWYgKGFyY19jID4gYXJjX2NfbWluKSB7CiAJCXVpbnQ2NF90 IHRvX2ZyZWU7CiAKQEAgLTI0MjksNiArMjQ3NSw5IEBACiAjZWxzZQogCQl0b19mcmVlID0gYXJj X2MgPj4gYXJjX3Nocmlua19zaGlmdDsKICNlbmRpZgorCQlEVFJBQ0VfUFJPQkU0KGFyY19fc2hy aW5rLCB1aW50NjRfdCwgYXJjX2MsIHVpbnQ2NF90LAorCQkJYXJjX2NfbWluLCB1aW50NjRfdCwg YXJjX3AsIHVpbnQ2NF90LCB0b19mcmVlKTsKKwogCQlpZiAoYXJjX2MgPiBhcmNfY19taW4gKyB0 b19mcmVlKQogCQkJYXRvbWljX2FkZF82NCgmYXJjX2MsIC10b19mcmVlKTsKIAkJZWxzZQpAQCAt MjQzOSwxMiArMjQ4OCwxOSBAQAogCQkJYXJjX2MgPSBNQVgoYXJjX3NpemUsIGFyY19jX21pbik7 CiAJCWlmIChhcmNfcCA+IGFyY19jKQogCQkJYXJjX3AgPSAoYXJjX2MgPj4gMSk7CisKKwkJRFRS QUNFX1BST0JFMihhcmNfX3NocnVuaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRfdCwKKwkJCWFy Y19wKTsKKwogCQlBU1NFUlQoYXJjX2MgPj0gYXJjX2NfbWluKTsKIAkJQVNTRVJUKChpbnQ2NF90 KWFyY19wID49IDApOwogCX0KIAotCWlmIChhcmNfc2l6ZSA+IGFyY19jKQorCWlmIChhcmNfc2l6 ZSA+IGFyY19jKSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19zaHJpbmtfYWRqdXN0LCB1aW50NjRf dCwgYXJjX3NpemUsCisJCQl1aW50NjRfdCwgYXJjX2MpOwogCQlhcmNfYWRqdXN0KCk7CisJfQog fQogCiBzdGF0aWMgaW50IG5lZWRmcmVlID0gMDsKQEAgLTI0NTIsMTggKzI1MDgsNTEgQEAKIHN0 YXRpYyBpbnQKIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogeworCXVfaW50IGZtOwogCiAjaWZk ZWYgX0tFUk5FTAogCi0JaWYgKG5lZWRmcmVlKQorLyoKKyAqIEZpcnN0IGNoZWNrIHRvIHNlZSBp ZiBkaXJ0eV9kYXRhX21heCBuZWVkcyBhZGp1c3RpbmcuICBEbyBub3QgYWxsb3cKKyAqIHRoZSBk aXJ0eSBkYXRhIGFtb3VudCBwZXIgcG9vbCB0byBleGNlZWQgZnJlZSwgbm9uLXN3YXBwYWJsZSBS QU0uCisgKiBTdWJqZWN0IHRoaXMgdG8gdGhlIG9yaWdpbmFsIHRlc3Qgb2YgdGhlIG1heF9tYXgg bGltaXQgYW5kIGEgbWluaW11bQorICogb2YgMTZNQi4KKyAqLworICAgICAgICB6ZnNfZGlydHlf ZGF0YV9tYXggPSBwdG9iKGNudC52X2ZyZWVfY291bnQpIC0gcHRvYihjbnQudl9mcmVlX21pbik7 CisgICAgICAgIGlmICh6ZnNfZGlydHlfZGF0YV9tYXggPD0gMSA8PCAyNCkgeworICAgICAgICAg ICAgICAgIHpmc19kaXJ0eV9kYXRhX21heCA9IDEgPDwgMjQ7CisgICAgICAgIH0KKyAgICAgICAg emZzX2RpcnR5X2RhdGFfbWF4ID0gTUlOKHpmc19kaXJ0eV9kYXRhX21heCwgcHRvYihwaHlzbWVt KSAqCisgICAgICAgICAgICAgICAgemZzX2RpcnR5X2RhdGFfbWF4X3BlcmNlbnQgLyAxMDApOwor ICAgICAgICB6ZnNfZGlydHlfZGF0YV9tYXggPSBNSU4oemZzX2RpcnR5X2RhdGFfbWF4LCB6ZnNf ZGlydHlfZGF0YV9tYXhfbWF4KTsKKworCisJaWYgKGFyY19zaXplIDw9IGFyY19jX21pbikgewor CQlEVFJBQ0VfUFJPQkUyKGFyY19fcmVjbGFpbV9taW4sIHVpbnQ2NF90LCBhcmNfc2l6ZSwKKwkJ ICAgIHVpbnQ2NF90LCBhcmNfY19taW4pOworCQlyZXR1cm4gKDApOworCX0KKworCWlmIChuZWVk ZnJlZSkgeworCQlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX25lZWRmcmVlKTsKIAkJcmV0dXJu ICgxKTsKKwl9CiAKIAkvKgogCSAqIENvb3BlcmF0ZSB3aXRoIHBhZ2VkYWVtb24gd2hlbiBpdCdz IHRpbWUgZm9yIGl0IHRvIHNjYW4KIAkgKiBhbmQgcmVjbGFpbSBzb21lIHBhZ2VzLgogCSAqLwot CWlmICh2bV9wYWdpbmdfbmVlZGVkKCkpCisJaWYgKHpmc19hcmNfcmVjbGFpbV9jYWNoZV9mcmVl ID09IDApCisJCWZtID0gY250LnZfZnJlZV9jb3VudDsKKwllbHNlCisJCWZtID0gZnJlZW1lbTsK KworCWlmIChmbSA8IHpmc19hcmNfZnJlZV90YXJnZXQpIHsKKwkJRFRSQUNFX1BST0JFMyhhcmNf X3JlY2xhaW1fZnJlZW1lbSwgdWludDY0X3QsCisJCSAgICBmbSwgdWludDY0X3QsIHpmc19hcmNf ZnJlZV90YXJnZXQsCisJCSAgICBpbnQsIHpmc19hcmNfcmVjbGFpbV9jYWNoZV9mcmVlKTsKIAkJ cmV0dXJuICgxKTsKKwl9CiAKICNpZmRlZiBzdW4KIAkvKgpAQCAtMjQ5MSw4ICsyNTgwLDE5IEBA CiAJaWYgKGF2YWlscm1lbSA8IHN3YXBmc19taW5mcmVlICsgc3dhcGZzX3Jlc2VydmUgKyBleHRy YSkKIAkJcmV0dXJuICgxKTsKIAotI2lmIGRlZmluZWQoX19pMzg2KQogCS8qCisJICogQ2hlY2sg dGhhdCB3ZSBoYXZlIGVub3VnaCBhdmFpbHJtZW0gdGhhdCBtZW1vcnkgbG9ja2luZyAoZS5nLiwg dmlhCisJICogbWxvY2soM0MpIG9yIG1lbWNudGwoMikpIGNhbiBzdGlsbCBzdWNjZWVkLiAgKHBh Z2VzX3BwX21heGltdW0KKwkgKiBzdG9yZXMgdGhlIG51bWJlciBvZiBwYWdlcyB0aGF0IGNhbm5v dCBiZSBsb2NrZWQ7IHdoZW4gYXZhaWxybWVtCisJICogZHJvcHMgYmVsb3cgcGFnZXNfcHBfbWF4 aW11bSwgcGFnZSBsb2NraW5nIG1lY2hhbmlzbXMgc3VjaCBhcworCSAqIHBhZ2VfcHBfbG9jaygp IHdpbGwgZmFpbC4pCisJICovCisJaWYgKGF2YWlscm1lbSA8PSBwYWdlc19wcF9tYXhpbXVtKQor CQlyZXR1cm4gKDEpOworCisjZW5kaWYJLyogc3VuICovCisjaWYgZGVmaW5lZChfX2kzODYpIHx8 ICFkZWZpbmVkKFVNQV9NRF9TTUFMTF9BTExPQykKKwkvKgogCSAqIElmIHdlJ3JlIG9uIGFuIGkz ODYgcGxhdGZvcm0sIGl0J3MgcG9zc2libGUgdGhhdCB3ZSdsbCBleGhhdXN0IHRoZQogCSAqIGtl cm5lbCBoZWFwIHNwYWNlIGJlZm9yZSB3ZSBldmVyIHJ1biBvdXQgb2YgYXZhaWxhYmxlIHBoeXNp Y2FsCiAJICogbWVtb3J5LiAgTW9zdCBjaGVja3Mgb2YgdGhlIHNpemUgb2YgdGhlIGhlYXBfYXJl YSBjb21wYXJlIGFnYWluc3QKQEAgLTI1MDMsMzIgKzI2MDMsNDkgQEAKIAkgKiBoZWFwIGlzIGFs bG9jYXRlZC4gIChPciwgaW4gdGhlIGNhbGN1bGF0aW9uLCBpZiBsZXNzIHRoYW4gMS80dGggaXMK IAkgKiBmcmVlKQogCSAqLwotCWlmIChidG9wKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZS RUUpKSA8Ci0JICAgIChidG9wKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUgfCBWTUVN X0FMTE9DKSkgPj4gMikpCisJaWYgKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpIDwK KwkgICAgKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUgfCBWTUVNX0FMTE9DKSA+PiAy KSkgeworCQlEVFJBQ0VfUFJPQkUyKGFyY19fcmVjbGFpbV91c2VkLCB1aW50NjRfdCwKKwkJICAg IHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpLCB1aW50NjRfdCwKKwkJICAgICh2bWVt X3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwgVk1FTV9BTExPQykpID4+IDIpOwogCQlyZXR1 cm4gKDEpOworCX0KICNlbmRpZgotI2Vsc2UJLyogIXN1biAqLwotCWlmIChrbWVtX3VzZWQoKSA+ IChrbWVtX3NpemUoKSAqIDMpIC8gNCkKKyNpZmRlZiBzdW4KKwkvKgorCSAqIElmIHppbyBkYXRh IHBhZ2VzIGFyZSBiZWluZyBhbGxvY2F0ZWQgb3V0IG9mIGEgc2VwYXJhdGUgaGVhcCBzZWdtZW50 LAorCSAqIHRoZW4gZW5mb3JjZSB0aGF0IHRoZSBzaXplIG9mIGF2YWlsYWJsZSB2bWVtIGZvciB0 aGlzIGFyZW5hIHJlbWFpbnMKKwkgKiBhYm92ZSBhYm91dCAxLzE2dGggZnJlZS4KKwkgKgorCSAq IE5vdGU6IFRoZSAxLzE2dGggYXJlbmEgZnJlZSByZXF1aXJlbWVudCB3YXMgcHV0IGluIHBsYWNl CisJICogdG8gYWdncmVzc2l2ZWx5IGV2aWN0IG1lbW9yeSBmcm9tIHRoZSBhcmMgaW4gb3JkZXIg dG8gYXZvaWQKKwkgKiBtZW1vcnkgZnJhZ21lbnRhdGlvbiBpc3N1ZXMuCisJICovCisJaWYgKHpp b19hcmVuYSAhPSBOVUxMICYmCisJICAgIHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fRlJFRSkg PAorCSAgICAodm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9BTExPQykgPj4gNCkpCiAJCXJldHVy biAoMSk7CiAjZW5kaWYJLyogc3VuICovCi0KLSNlbHNlCisjZWxzZQkvKiBfS0VSTkVMICovCiAJ aWYgKHNwYV9nZXRfcmFuZG9tKDEwMCkgPT0gMCkKIAkJcmV0dXJuICgxKTsKLSNlbmRpZgorI2Vu ZGlmCS8qIF9LRVJORUwgKi8KKwlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX25vKTsKKwogCXJl dHVybiAoMCk7CiB9CiAKIGV4dGVybiBrbWVtX2NhY2hlX3QJKnppb19idWZfY2FjaGVbXTsKIGV4 dGVybiBrbWVtX2NhY2hlX3QJKnppb19kYXRhX2J1Zl9jYWNoZVtdOwogCi1zdGF0aWMgdm9pZAor c3RhdGljIHZvaWQgX191c2VkCiBhcmNfa21lbV9yZWFwX25vdyhhcmNfcmVjbGFpbV9zdHJhdGVn eV90IHN0cmF0KQogewogCXNpemVfdAkJCWk7CiAJa21lbV9jYWNoZV90CQkqcHJldl9jYWNoZSA9 IE5VTEw7CiAJa21lbV9jYWNoZV90CQkqcHJldl9kYXRhX2NhY2hlID0gTlVMTDsKIAorCURUUkFD RV9QUk9CRShhcmNfX2ttZW1fcmVhcF9zdGFydCk7CiAjaWZkZWYgX0tFUk5FTAogCWlmIChhcmNf bWV0YV91c2VkID49IGFyY19tZXRhX2xpbWl0KSB7CiAJCS8qCkBAIC0yNTY0LDYgKzI2ODEsMTYg QEAKIAl9CiAJa21lbV9jYWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOwogCWttZW1fY2FjaGVfcmVh cF9ub3coaGRyX2NhY2hlKTsKKworI2lmZGVmIHN1bgorCS8qCisJICogQXNrIHRoZSB2bWVtIGFy ZWFuYSB0byByZWNsYWltIHVudXNlZCBtZW1vcnkgZnJvbSBpdHMKKwkgKiBxdWFudHVtIGNhY2hl cy4KKwkgKi8KKwlpZiAoemlvX2FyZW5hICE9IE5VTEwgJiYgc3RyYXQgPT0gQVJDX1JFQ0xBSU1f QUdHUikKKwkJdm1lbV9xY2FjaGVfcmVhcCh6aW9fYXJlbmEpOworI2VuZGlmCisJRFRSQUNFX1BS T0JFKGFyY19fa21lbV9yZWFwX2VuZCk7CiB9CiAKIHN0YXRpYyB2b2lkCkBAIC0yNTgxLDYgKzI3 MDgsNyBAQAogCiAJCQlpZiAoYXJjX25vX2dyb3cpIHsKIAkJCQlpZiAobGFzdF9yZWNsYWltID09 IEFSQ19SRUNMQUlNX0NPTlMpIHsKKwkJCQkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9hZ2dy X25vX2dyb3cpOwogCQkJCQlsYXN0X3JlY2xhaW0gPSBBUkNfUkVDTEFJTV9BR0dSOwogCQkJCX0g ZWxzZSB7CiAJCQkJCWxhc3RfcmVjbGFpbSA9IEFSQ19SRUNMQUlNX0NPTlM7CkBAIC0yNTg4LDYg KzI3MTYsNyBAQAogCQkJfSBlbHNlIHsKIAkJCQlhcmNfbm9fZ3JvdyA9IFRSVUU7CiAJCQkJbGFz dF9yZWNsYWltID0gQVJDX1JFQ0xBSU1fQUdHUjsKKwkJCQlEVFJBQ0VfUFJPQkUoYXJjX19yZWNs YWltX2FnZ3IpOwogCQkJCW1lbWJhcl9wcm9kdWNlcigpOwogCQkJfQogCkBAIC0yNjAyLDYgKzI3 MzEsNyBAQAogCQkJCSAqLwogCQkJCWFyY19ub19ncm93ID0gVFJVRTsKIAkJCQlsYXN0X3JlY2xh aW0gPSBBUkNfUkVDTEFJTV9BR0dSOworCQkJCURUUkFDRV9QUk9CRShhcmNfX3JlY2xhaW1fYWdn cl9uZWVkZnJlZSk7CiAJCQl9CiAJCQlhcmNfa21lbV9yZWFwX25vdyhsYXN0X3JlY2xhaW0pOwog CQkJYXJjX3dhcm0gPSBCX1RSVUU7CkBAIC0yNjE4LDYgKzI3NDgsNyBAQAogI2lmZGVmIF9LRVJO RUwKIAkJaWYgKG5lZWRmcmVlKSB7CiAJCQluZWVkZnJlZSA9IDA7CisJCQlEVFJBQ0VfUFJPQkUo YXJjX19jbGVhcl9uZWVkZnJlZSk7CiAJCQl3YWtldXAoJm5lZWRmcmVlKTsKIAkJfQogI2VuZGlm CkBAIC0yNjkyLDYgKzI4MjMsNyBAQAogCSAqIGNhY2hlIHNpemUsIGluY3JlbWVudCB0aGUgdGFy Z2V0IGNhY2hlIHNpemUKIAkgKi8KIAlpZiAoYXJjX3NpemUgPiBhcmNfYyAtICgyVUxMIDw8IFNQ QV9NQVhCTE9DS1NISUZUKSkgeworCQlEVFJBQ0VfUFJPQkUxKGFyY19faW5jX2FkYXB0LCBpbnQs IGJ5dGVzKTsKIAkJYXRvbWljX2FkZF82NCgmYXJjX2MsIChpbnQ2NF90KWJ5dGVzKTsKIAkJaWYg KGFyY19jID4gYXJjX2NfbWF4KQogCQkJYXJjX2MgPSBhcmNfY19tYXg7CkBAIC0yNzEzLDIwICsy ODQ1LDYgQEAKIAlpZiAodHlwZSA9PSBBUkNfQlVGQ19NRVRBREFUQSAmJiBhcmNfbWV0YV91c2Vk ID49IGFyY19tZXRhX2xpbWl0KQogCQlyZXR1cm4gKDEpOwogCi0jaWZkZWYgc3VuCi0jaWZkZWYg X0tFUk5FTAotCS8qCi0JICogSWYgemlvIGRhdGEgcGFnZXMgYXJlIGJlaW5nIGFsbG9jYXRlZCBv dXQgb2YgYSBzZXBhcmF0ZSBoZWFwIHNlZ21lbnQsCi0JICogdGhlbiBlbmZvcmNlIHRoYXQgdGhl IHNpemUgb2YgYXZhaWxhYmxlIHZtZW0gZm9yIHRoaXMgYXJlYSByZW1haW5zCi0JICogYWJvdmUg YWJvdXQgMS8zMm5kIGZyZWUuCi0JICovCi0JaWYgKHR5cGUgPT0gQVJDX0JVRkNfREFUQSAmJiB6 aW9fYXJlbmEgIT0gTlVMTCAmJgotCSAgICB2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0ZSRUUp IDwKLQkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fQUxMT0MpID4+IDUpKQotCQlyZXR1 cm4gKDEpOwotI2VuZGlmCi0jZW5kaWYJLyogc3VuICovCi0KIAlpZiAoYXJjX3JlY2xhaW1fbmVl ZGVkKCkpCiAJCXJldHVybiAoMSk7CiAKQEAgLTM4ODUsMjAgKzQwMDMsMTYgQEAKIGFyY19tZW1v cnlfdGhyb3R0bGUodWludDY0X3QgcmVzZXJ2ZSwgdWludDY0X3QgdHhnKQogewogI2lmZGVmIF9L RVJORUwKLQl1aW50NjRfdCBhdmFpbGFibGVfbWVtb3J5ID0KLQkgICAgcHRvYSgodWludG1heF90 KWNudC52X2ZyZWVfY291bnQgKyBjbnQudl9jYWNoZV9jb3VudCk7CisJdWludDY0X3QgYXZhaWxh YmxlX21lbW9yeSA9IHB0b2IoZnJlZW1lbSk7CiAJc3RhdGljIHVpbnQ2NF90IHBhZ2VfbG9hZCA9 IDA7CiAJc3RhdGljIHVpbnQ2NF90IGxhc3RfdHhnID0gMDsKIAotI2lmZGVmIHN1bgotI2lmIGRl ZmluZWQoX19pMzg2KQorI2lmIGRlZmluZWQoX19pMzg2KSB8fCAhZGVmaW5lZChVTUFfTURfU01B TExfQUxMT0MpCiAJYXZhaWxhYmxlX21lbW9yeSA9Ci0JICAgIE1JTihhdmFpbGFibGVfbWVtb3J5 LCB2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSk7CisJICAgIE1JTihhdmFpbGFibGVf bWVtb3J5LCBwdG9iKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpKSk7CiAjZW5kaWYK LSNlbmRpZgkvKiBzdW4gKi8KIAotCWlmIChjbnQudl9mcmVlX2NvdW50ICsgY250LnZfY2FjaGVf Y291bnQgPgotCSAgICAodWludDY0X3QpcGh5c21lbSAqIGFyY19sb3RzZnJlZV9wZXJjZW50IC8g MTAwKQorCWlmIChmcmVlbWVtID4gKHVpbnQ2NF90KXBoeXNtZW0gKiBhcmNfbG90c2ZyZWVfcGVy Y2VudCAvIDEwMCkKIAkJcmV0dXJuICgwKTsKIAogCWlmICh0eGcgPiBsYXN0X3R4ZykgewpAQCAt MzkxMSw3ICs0MDI1LDcgQEAKIAkgKiBjb250aW51ZSB0byBsZXQgcGFnZSB3cml0ZXMgb2NjdXIg YXMgcXVpY2tseSBhcyBwb3NzaWJsZS4KIAkgKi8KIAlpZiAoY3VycHJvYyA9PSBwYWdlcHJvYykg ewotCQlpZiAocGFnZV9sb2FkID4gYXZhaWxhYmxlX21lbW9yeSAvIDQpCisJCWlmIChwYWdlX2xv YWQgPiBNQVgocHRvYihtaW5mcmVlKSwgYXZhaWxhYmxlX21lbW9yeSkgLyA0KQogCQkJcmV0dXJu IChTRVRfRVJST1IoRVJFU1RBUlQpKTsKIAkJLyogTm90ZTogcmVzZXJ2ZSBpcyBpbmZsYXRlZCwg c28gd2UgZGVmbGF0ZSAqLwogCQlwYWdlX2xvYWQgKz0gcmVzZXJ2ZSAvIDg7CkBAIC0zOTM5LDgg KzQwNTMsMTAgQEAKIAlpbnQgZXJyb3I7CiAJdWludDY0X3QgYW5vbl9zaXplOwogCi0JaWYgKHJl c2VydmUgPiBhcmNfYy80ICYmICFhcmNfbm9fZ3JvdykKKwlpZiAocmVzZXJ2ZSA+IGFyY19jLzQg JiYgIWFyY19ub19ncm93KSB7CiAJCWFyY19jID0gTUlOKGFyY19jX21heCwgcmVzZXJ2ZSAqIDQp OworCQlEVFJBQ0VfUFJPQkUxKGFyY19fc2V0X3Jlc2VydmUsIHVpbnQ2NF90LCBhcmNfYyk7CisJ fQogCWlmIChyZXNlcnZlID4gYXJjX2MpCiAJCXJldHVybiAoU0VUX0VSUk9SKEVOT01FTSkpOwog CkBAIC0zOTk0LDYgKzQxMTAsNyBAQAogCW11dGV4X2VudGVyKCZhcmNfbG93bWVtX2xvY2spOwog CW11dGV4X2VudGVyKCZhcmNfcmVjbGFpbV90aHJfbG9jayk7CiAJbmVlZGZyZWUgPSAxOworCURU UkFDRV9QUk9CRShhcmNfX25lZWRmcmVlKTsKIAljdl9zaWduYWwoJmFyY19yZWNsYWltX3Rocl9j dik7CiAKIAkvKgpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9u L2ZzL3pmcy9kbXVfdHguYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xh cmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90eC5jCShyZXZpc2lvbiAyNzE0MzUpCisrKyBzeXMv Y2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90eC5jCSh3b3Jr aW5nIGNvcHkpCkBAIC0xMDYzLDYgKzEwNjMsMTMgQEAKIAlBU1NFUlQzVShkaXJ0eSwgPCwgemZz X2RpcnR5X2RhdGFfbWF4KTsKIAogCW5vdyA9IGdldGhydGltZSgpOworCS8qCisJICogQmVjYXVz ZSBvZiBkeW5hbWljIGRpcnR5X2RhdGFfbWF4IHNpemluZyBpbiBhcmMuYywgaXQgaXMgcG9zc2li bGUKKwkgKiBmb3IgaXQgdG8gYmUgZXhhY3RseSBlcXVhbCB0byBkaXJ0eS4gIFByZXZlbnQgZGl2 aWRlLWJ5LXplcm8gcGFuaWMKKwkgKiBpbiB0aGUgdW5saWtlbHkgZXZlbnQgdGhhdCBoYXBwZW5z IHRvIGJlIHRoZSBjYXNlLgorCSAqLworCWlmICEoemZzX2RpcnR5X2RhdGFfbWF4IC0gZGlydHkp CisJCXpmc19kaXJ0eV9kYXRhX21heCsrOwogCW1pbl90eF90aW1lID0gemZzX2RlbGF5X3NjYWxl ICoKIAkgICAgKGRpcnR5IC0gZGVsYXlfbWluX2J5dGVzKSAvICh6ZnNfZGlydHlfZGF0YV9tYXgg LSBkaXJ0eSk7CiAJaWYgKG5vdyA+IHR4LT50eF9zdGFydCArIG1pbl90eF90aW1lKQpJbmRleDog c3lzL3ZtL3ZtX3BhZ2VvdXQuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvdm0vdm1fcGFnZW91dC5jCShy ZXZpc2lvbiAyNzE0MzUpCisrKyBzeXMvdm0vdm1fcGFnZW91dC5jCSh3b3JraW5nIGNvcHkpCkBA IC03Niw2ICs3Niw3IEBACiBfX0ZCU0RJRCgiJEZyZWVCU0QkIik7CiAKICNpbmNsdWRlICJvcHRf dm0uaCIKKyNpbmNsdWRlICJvcHRfa2R0cmFjZS5oIgogI2luY2x1ZGUgPHN5cy9wYXJhbS5oPgog I2luY2x1ZGUgPHN5cy9zeXN0bS5oPgogI2luY2x1ZGUgPHN5cy9rZXJuZWwuaD4KQEAgLTg5LDYg KzkwLDcgQEAKICNpbmNsdWRlIDxzeXMvcmFjY3QuaD4KICNpbmNsdWRlIDxzeXMvcmVzb3VyY2V2 YXIuaD4KICNpbmNsdWRlIDxzeXMvc2NoZWQuaD4KKyNpbmNsdWRlIDxzeXMvc2R0Lmg+CiAjaW5j bHVkZSA8c3lzL3NpZ25hbHZhci5oPgogI2luY2x1ZGUgPHN5cy9zbXAuaD4KICNpbmNsdWRlIDxz eXMvdm5vZGUuaD4KQEAgLTExNSwxMCArMTE3LDE0IEBACiAKIC8qIHRoZSBrZXJuZWwgcHJvY2Vz cyAidm1fcGFnZW91dCIqLwogc3RhdGljIHZvaWQgdm1fcGFnZW91dCh2b2lkKTsKK3N0YXRpYyB2 b2lkIHZtX3BhZ2VvdXRfaW5pdCh2b2lkKTsKIHN0YXRpYyBpbnQgdm1fcGFnZW91dF9jbGVhbih2 bV9wYWdlX3QpOwogc3RhdGljIHZvaWQgdm1fcGFnZW91dF9zY2FuKHN0cnVjdCB2bV9kb21haW4g KnZtZCwgaW50IHBhc3MpOwogc3RhdGljIHZvaWQgdm1fcGFnZW91dF9taWdodGJlX29vbShzdHJ1 Y3Qgdm1fZG9tYWluICp2bWQsIGludCBwYXNzKTsKIAorU1lTSU5JVChwYWdlZGFlbW9uX2luaXQs IFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX0ZJUlNULCB2bV9wYWdlb3V0X2luaXQsCisg ICAgTlVMTCk7CisKIHN0cnVjdCBwcm9jICpwYWdlcHJvYzsKIAogc3RhdGljIHN0cnVjdCBrcHJv Y19kZXNjIHBhZ2Vfa3AgPSB7CkBAIC0xMjYsOSArMTMyLDEzIEBACiAJdm1fcGFnZW91dCwKIAkm cGFnZXByb2MKIH07Ci1TWVNJTklUKHBhZ2VkYWVtb24sIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJ X09SREVSX0ZJUlNULCBrcHJvY19zdGFydCwKK1NZU0lOSVQocGFnZWRhZW1vbiwgU0lfU1VCX0tU SFJFQURfUEFHRSwgU0lfT1JERVJfU0VDT05ELCBrcHJvY19zdGFydCwKICAgICAmcGFnZV9rcCk7 CiAKK1NEVF9QUk9WSURFUl9ERUZJTkUodm0pOworU0RUX1BST0JFX0RFRklORSh2bSwgLCAsIHZt X19sb3dtZW1fY2FjaGUpOworU0RUX1BST0JFX0RFRklORSh2bSwgLCAsIHZtX19sb3dtZW1fc2Nh bik7CisKICNpZiAhZGVmaW5lZChOT19TV0FQUElORykKIC8qIHRoZSBrZXJuZWwgcHJvY2VzcyAi dm1fZGFlbW9uIiovCiBzdGF0aWMgdm9pZCB2bV9kYWVtb24odm9pZCk7CkBAIC02NjMsNiArNjcz LDcgQEAKIAkJICogbWF5IGFjcXVpcmUgbG9ja3MgYW5kL29yIHNsZWVwLCBzbyB0aGV5IGNhbiBv bmx5IGJlIGludm9rZWQKIAkJICogd2hlbiAidHJpZXMiIGlzIGdyZWF0ZXIgdGhhbiB6ZXJvLgog CQkgKi8KKwkJU0RUX1BST0JFMCh2bSwgLCAsIHZtX19sb3dtZW1fY2FjaGUpOwogCQlFVkVOVEhB TkRMRVJfSU5WT0tFKHZtX2xvd21lbSwgMCk7CiAKIAkJLyoKQEAgLTkwNCw3ICs5MTUsNyBAQAog ICoJcGFzcyAxIC0gTW92ZSBpbmFjdGl2ZSB0byBjYWNoZSBvciBmcmVlCiAgKglwYXNzIDIgLSBM YXVuZGVyIGRpcnR5IHBhZ2VzCiAgKi8KLXN0YXRpYyB2b2lkCitzdGF0aWMgdm9pZCBfX3VzZWQK IHZtX3BhZ2VvdXRfc2NhbihzdHJ1Y3Qgdm1fZG9tYWluICp2bWQsIGludCBwYXNzKQogewogCXZt X3BhZ2VfdCBtLCBuZXh0OwpAQCAtOTI1LDYgKzkzNiw3IEBACiAJCS8qCiAJCSAqIERlY3JlYXNl IHJlZ2lzdGVyZWQgY2FjaGUgc2l6ZXMuCiAJCSAqLworCQlTRFRfUFJPQkUwKHZtLCAsICwgdm1f X2xvd21lbV9zY2FuKTsKIAkJRVZFTlRIQU5ETEVSX0lOVk9LRSh2bV9sb3dtZW0sIDApOwogCQkv KgogCQkgKiBXZSBkbyB0aGlzIGV4cGxpY2l0bHkgYWZ0ZXIgdGhlIGNhY2hlcyBoYXZlIGJlZW4K QEAgLTE2NTAsMTUgKzE2NjIsMTEgQEAKIH0KIAogLyoKLSAqCXZtX3BhZ2VvdXQgaXMgdGhlIGhp Z2ggbGV2ZWwgcGFnZW91dCBkYWVtb24uCisgKgl2bV9wYWdlb3V0X2luaXQgaW5pdGlhbGlzZXMg YmFzaWMgcGFnZW91dCBkYWVtb24gc2V0dGluZ3MuCiAgKi8KIHN0YXRpYyB2b2lkCi12bV9wYWdl b3V0KHZvaWQpCit2bV9wYWdlb3V0X2luaXQodm9pZCkKIHsKLSNpZiBNQVhNRU1ET00gPiAxCi0J aW50IGVycm9yLCBpOwotI2VuZGlmCi0KIAkvKgogCSAqIEluaXRpYWxpemUgc29tZSBwYWdpbmcg cGFyYW1ldGVycy4KIAkgKi8KQEAgLTE3MDQsNyArMTcxMiwxOCBAQAogCS8qIFhYWCBkb2VzIG5v dCByZWFsbHkgYmVsb25nIGhlcmUgKi8KIAlpZiAodm1fcGFnZV9tYXhfd2lyZWQgPT0gMCkKIAkJ dm1fcGFnZV9tYXhfd2lyZWQgPSBjbnQudl9mcmVlX2NvdW50IC8gMzsKK30KIAorLyoKKyAqICAg ICB2bV9wYWdlb3V0IGlzIHRoZSBoaWdoIGxldmVsIHBhZ2VvdXQgZGFlbW9uLgorICovCitzdGF0 aWMgdm9pZAordm1fcGFnZW91dCh2b2lkKQoreworI2lmIE1BWE1FTURPTSA+IDEKKwlpbnQgZXJy b3IsIGk7CisjZW5kaWYKKwogCXN3YXBfcGFnZXJfc3dhcF9pbml0KCk7CiAjaWYgTUFYTUVNRE9N ID4gMQogCWZvciAoaSA9IDE7IGkgPCB2bV9uZG9tYWluczsgaSsrKSB7Cg== 147286 2014-09-13 20:34:10 +0000 2014-09-19 01:45:02 +0000 Candidate Fix (supersedes previous) patch-stable-10 text/plain 15610 karl SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MTQzNSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTMzLDEzICsx MzMsNiBAQAogCXJldHVybiAoa21lbV9zaXplX3ZhbCk7CiB9CiAKLXVpbnQ2NF90Ci1rbWVtX3Vz ZWQodm9pZCkKLXsKLQotCXJldHVybiAodm1lbV9zaXplKGttZW1fYXJlbmEsIFZNRU1fQUxMT0Mp KTsKLX0KLQogc3RhdGljIGludAoga21lbV9zdGRfY29uc3RydWN0b3Iodm9pZCAqbWVtLCBpbnQg c2l6ZSBfX3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgaW50IGZsYWdzKQogewpJbmRleDogc3lzL2Nk ZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwv Y29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgJKHJldmlzaW9uIDI3MTQzNSkKKysrIHN5cy9j ZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCSh3b3JraW5nIGNvcHkpCkBAIC02Niw3 ICs2Niw2IEBACiB2b2lkICp6ZnNfa21lbV9hbGxvYyhzaXplX3Qgc2l6ZSwgaW50IGttZmxhZ3Mp Owogdm9pZCB6ZnNfa21lbV9mcmVlKHZvaWQgKmJ1Ziwgc2l6ZV90IHNpemUpOwogdWludDY0X3Qg a21lbV9zaXplKHZvaWQpOwotdWludDY0X3Qga21lbV91c2VkKHZvaWQpOwoga21lbV9jYWNoZV90 ICprbWVtX2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3QgYnVmc2l6ZSwgc2l6ZV90IGFs aWduLAogICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZvaWQgKiwgaW50KSwgdm9pZCAo KmRlc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lkICgqcmVjbGFpbSkodm9pZCAq KSBfX3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAsIGludCBjZmxhZ3MpOwpAQCAt NzgsNiArNzcsOSBAQAogaW50IGttZW1fZGVidWdnaW5nKHZvaWQpOwogdm9pZCAqY2FsbG9jKHNp emVfdCBuLCBzaXplX3Qgcyk7CiAKKyNkZWZpbmUJZnJlZW1lbQkJCQkoY250LnZfZnJlZV9jb3Vu dCArIGNudC52X2NhY2hlX2NvdW50KQorI2RlZmluZQltaW5mcmVlCQkJCWNudC52X2ZyZWVfbWlu CisjZGVmaW5lCWhlYXBfYXJlbmEJCQlrbWVtX2FyZW5hCiAjZGVmaW5lCWttZW1fYWxsb2Moc2l6 ZSwga21mbGFncykJemZzX2ttZW1fYWxsb2MoKHNpemUpLCAoa21mbGFncykpCiAjZGVmaW5lCWtt ZW1femFsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChzaXplKSwgKGttZmxhZ3Mp IHwgTV9aRVJPKQogI2RlZmluZQlrbWVtX2ZyZWUoYnVmLCBzaXplKQkJemZzX2ttZW1fZnJlZSgo YnVmKSwgKHNpemUpKQpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29t bW9uL2ZzL3pmcy9hcmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xh cmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzE0MzUpCisrKyBzeXMvY2Rk bC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3b3JraW5nIGNv cHkpCkBAIC0xMzgsNiArMTM4LDcgQEAKICNpbmNsdWRlIDxzeXMvc2R0Lmg+CiAKICNpbmNsdWRl IDx2bS92bV9wYWdlb3V0Lmg+CisjaW5jbHVkZSA8bWFjaGluZS92bXBhcmFtLmg+CiAKICNpZmRl ZiBpbGx1bW9zCiAjaWZuZGVmIF9LRVJORUwKQEAgLTE5Myw5ICsxOTQsNiBAQAogICovCiBzdGF0 aWMgYm9vbGVhbl90IGFyY193YXJtOwogCi0vKgotICogVGhlc2UgdHVuYWJsZXMgYXJlIGZvciBw ZXJmb3JtYW5jZSBhbmFseXNpcy4KLSAqLwogdWludDY0X3QgemZzX2FyY19tYXg7CiB1aW50NjRf dCB6ZnNfYXJjX21pbjsKIHVpbnQ2NF90IHpmc19hcmNfbWV0YV9saW1pdCA9IDA7CkBAIC0yMDQs NyArMjAyLDIxIEBACiBpbnQgemZzX2FyY19wX21pbl9zaGlmdCA9IDA7CiBpbnQgemZzX2Rpc2Fi bGVfZHVwX2V2aWN0aW9uID0gMDsKIHVpbnQ2NF90IHpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUg PSA4ICogMTAyNDsgLyogOEtCICovCit1X2ludCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gKDEgPDwg MTYpOyAvKiBkZWZhdWx0IGJlZm9yZSBwYWdlZGFlbW9uIGluaXQgb25seSAqLworaW50IHpmc19h cmNfcmVjbGFpbV9jYWNoZV9mcmVlID0gMTsKIAorc3RhdGljIGludCBzeXNjdGxfdmZzX3pmc19h cmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CisKKyNpZmRlZiBfS0VSTkVMCitz dGF0aWMgdm9pZAorYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQor eworCisJemZzX2FyY19mcmVlX3RhcmdldCA9IGNudC52X2ZyZWVfdGFyZ2V0OworfQorU1lTSU5J VChhcmNfZnJlZV90YXJnZXRfaW5pdCwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfQU5Z LAorICAgIGFyY19mcmVlX3RhcmdldF9pbml0LCBOVUxMKTsKKwogVFVOQUJMRV9RVUFEKCJ2ZnMu emZzLmFyY19tYXgiLCAmemZzX2FyY19tYXgpOwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19t aW4iLCAmemZzX2FyY19taW4pOwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19tZXRhX2xpbWl0 IiwgJnpmc19hcmNfbWV0YV9saW1pdCk7CkBAIC0yMTcsNyArMjI5LDQwIEBACiBTWVNDVExfVVFV QUQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfYXZlcmFnZV9ibG9ja3NpemUsIENUTEZMQUdfUkRU VU4sCiAgICAgJnpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUsIDAsCiAgICAgIkFSQyBhdmVyYWdl IGJsb2Nrc2l6ZSIpOworU1lTQ1RMX0lOVChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19yZWNsYWlt X2NhY2hlX2ZyZWUsIENUTEZMQUdfUldUVU4sCisgICAgJnpmc19hcmNfcmVjbGFpbV9jYWNoZV9m cmVlLCAwLAorICAgICJBUkMgdHJlYXRzIGNhY2hlZCBwYWdlcyBhcyBmcmVlIGJsb2Nrc2l6ZSIp OworLyoKKyAqIFdlIGRvbid0IGhhdmUgYSB0dW5hYmxlIGZvciBhcmNfZnJlZV90YXJnZXQgZHVl IHRvIHRoZSBkZXBlbmRlbmN5IG9uCisgKiBwYWdlZGFlbW9uIGluaXRpYWxpc2F0aW9uLgorICov CitTWVNDVExfUFJPQyhfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19mcmVlX3RhcmdldCwKKyAgICBD VExUWVBFX1VJTlQgfCBDVExGTEFHX01QU0FGRSB8IENUTEZMQUdfUlcsIDAsIHNpemVvZih1X2lu dCksCisgICAgc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0LCAiSVUiLAorICAgICJEZXNp cmVkIG51bWJlciBvZiBmcmVlIHBhZ2VzIGJlbG93IHdoaWNoIEFSQyB0cmlnZ2VycyByZWNsYWlt Iik7CiAKK3N0YXRpYyBpbnQKK3N5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldChTWVNDVExf SEFORExFUl9BUkdTKQoreworCXVfaW50IHZhbDsKKwlpbnQgZXJyOworCisJdmFsID0gemZzX2Fy Y19mcmVlX3RhcmdldDsKKwllcnIgPSBzeXNjdGxfaGFuZGxlX2ludChvaWRwLCAmdmFsLCAwLCBy ZXEpOworCWlmIChlcnIgIT0gMCB8fCByZXEtPm5ld3B0ciA9PSBOVUxMKQorCQlyZXR1cm4gKGVy cik7CisKKwlpZiAodmFsIDwgbWluZnJlZSkKKwkJcmV0dXJuIChFSU5WQUwpOworCWlmICh2YWwg PiBjbnQudl9wYWdlX2NvdW50KQorCQlyZXR1cm4gKEVJTlZBTCk7CisKKwl6ZnNfYXJjX2ZyZWVf dGFyZ2V0ID0gdmFsOworCisJcmV0dXJuICgwKTsKK30KKyNlbmRpZgorCiAvKgogICogTm90ZSB0 aGF0IGJ1ZmZlcnMgY2FuIGJlIGluIG9uZSBvZiA2IHN0YXRlczoKICAqCUFSQ19hbm9uCS0gYW5v bnltb3VzIChkaXNjdXNzZWQgYmVsb3cpCkBAIC0yNDIxLDYgKzI0NjYsNyBAQAogdm9pZAogYXJj X3Nocmluayh2b2lkKQogeworCiAJaWYgKGFyY19jID4gYXJjX2NfbWluKSB7CiAJCXVpbnQ2NF90 IHRvX2ZyZWU7CiAKQEAgLTI0MjksNiArMjQ3NSw5IEBACiAjZWxzZQogCQl0b19mcmVlID0gYXJj X2MgPj4gYXJjX3Nocmlua19zaGlmdDsKICNlbmRpZgorCQlEVFJBQ0VfUFJPQkU0KGFyY19fc2hy aW5rLCB1aW50NjRfdCwgYXJjX2MsIHVpbnQ2NF90LAorCQkJYXJjX2NfbWluLCB1aW50NjRfdCwg YXJjX3AsIHVpbnQ2NF90LCB0b19mcmVlKTsKKwogCQlpZiAoYXJjX2MgPiBhcmNfY19taW4gKyB0 b19mcmVlKQogCQkJYXRvbWljX2FkZF82NCgmYXJjX2MsIC10b19mcmVlKTsKIAkJZWxzZQpAQCAt MjQzOSwxMiArMjQ4OCwxOSBAQAogCQkJYXJjX2MgPSBNQVgoYXJjX3NpemUsIGFyY19jX21pbik7 CiAJCWlmIChhcmNfcCA+IGFyY19jKQogCQkJYXJjX3AgPSAoYXJjX2MgPj4gMSk7CisKKwkJRFRS QUNFX1BST0JFMihhcmNfX3NocnVuaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRfdCwKKwkJCWFy Y19wKTsKKwogCQlBU1NFUlQoYXJjX2MgPj0gYXJjX2NfbWluKTsKIAkJQVNTRVJUKChpbnQ2NF90 KWFyY19wID49IDApOwogCX0KIAotCWlmIChhcmNfc2l6ZSA+IGFyY19jKQorCWlmIChhcmNfc2l6 ZSA+IGFyY19jKSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19zaHJpbmtfYWRqdXN0LCB1aW50NjRf dCwgYXJjX3NpemUsCisJCQl1aW50NjRfdCwgYXJjX2MpOwogCQlhcmNfYWRqdXN0KCk7CisJfQog fQogCiBzdGF0aWMgaW50IG5lZWRmcmVlID0gMDsKQEAgLTI0NTIsMTggKzI1MDgsMzYgQEAKIHN0 YXRpYyBpbnQKIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogeworCXVfaW50IGZtOwogCiAjaWZk ZWYgX0tFUk5FTAogCi0JaWYgKG5lZWRmcmVlKQorCWlmIChhcmNfc2l6ZSA8PSBhcmNfY19taW4p IHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fbWluLCB1aW50NjRfdCwgYXJjX3NpemUs CisJCSAgICB1aW50NjRfdCwgYXJjX2NfbWluKTsKKwkJcmV0dXJuICgwKTsKKwl9CisKKwlpZiAo bmVlZGZyZWUpIHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9uZWVkZnJlZSk7CiAJCXJl dHVybiAoMSk7CisJfQogCiAJLyoKIAkgKiBDb29wZXJhdGUgd2l0aCBwYWdlZGFlbW9uIHdoZW4g aXQncyB0aW1lIGZvciBpdCB0byBzY2FuCiAJICogYW5kIHJlY2xhaW0gc29tZSBwYWdlcy4KIAkg Ki8KLQlpZiAodm1fcGFnaW5nX25lZWRlZCgpKQorCWlmICh6ZnNfYXJjX3JlY2xhaW1fY2FjaGVf ZnJlZSA9PSAwKQorCQlmbSA9IGNudC52X2ZyZWVfY291bnQ7CisJZWxzZQorCQlmbSA9IGZyZWVt ZW07CisKKwlpZiAoZm0gPCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KSB7CisJCURUUkFDRV9QUk9CRTMo YXJjX19yZWNsYWltX2ZyZWVtZW0sIHVpbnQ2NF90LAorCQkgICAgZm0sIHVpbnQ2NF90LCB6ZnNf YXJjX2ZyZWVfdGFyZ2V0LAorCQkgICAgaW50LCB6ZnNfYXJjX3JlY2xhaW1fY2FjaGVfZnJlZSk7 CiAJCXJldHVybiAoMSk7CisJfQogCiAjaWZkZWYgc3VuCiAJLyoKQEAgLTI0OTEsOCArMjU2NSwx OSBAQAogCWlmIChhdmFpbHJtZW0gPCBzd2FwZnNfbWluZnJlZSArIHN3YXBmc19yZXNlcnZlICsg ZXh0cmEpCiAJCXJldHVybiAoMSk7CiAKLSNpZiBkZWZpbmVkKF9faTM4NikKIAkvKgorCSAqIENo ZWNrIHRoYXQgd2UgaGF2ZSBlbm91Z2ggYXZhaWxybWVtIHRoYXQgbWVtb3J5IGxvY2tpbmcgKGUu Zy4sIHZpYQorCSAqIG1sb2NrKDNDKSBvciBtZW1jbnRsKDIpKSBjYW4gc3RpbGwgc3VjY2VlZC4g IChwYWdlc19wcF9tYXhpbXVtCisJICogc3RvcmVzIHRoZSBudW1iZXIgb2YgcGFnZXMgdGhhdCBj YW5ub3QgYmUgbG9ja2VkOyB3aGVuIGF2YWlscm1lbQorCSAqIGRyb3BzIGJlbG93IHBhZ2VzX3Bw X21heGltdW0sIHBhZ2UgbG9ja2luZyBtZWNoYW5pc21zIHN1Y2ggYXMKKwkgKiBwYWdlX3BwX2xv Y2soKSB3aWxsIGZhaWwuKQorCSAqLworCWlmIChhdmFpbHJtZW0gPD0gcGFnZXNfcHBfbWF4aW11 bSkKKwkJcmV0dXJuICgxKTsKKworI2VuZGlmCS8qIHN1biAqLworI2lmIGRlZmluZWQoX19pMzg2 KSB8fCAhZGVmaW5lZChVTUFfTURfU01BTExfQUxMT0MpCisJLyoKIAkgKiBJZiB3ZSdyZSBvbiBh biBpMzg2IHBsYXRmb3JtLCBpdCdzIHBvc3NpYmxlIHRoYXQgd2UnbGwgZXhoYXVzdCB0aGUKIAkg KiBrZXJuZWwgaGVhcCBzcGFjZSBiZWZvcmUgd2UgZXZlciBydW4gb3V0IG9mIGF2YWlsYWJsZSBw aHlzaWNhbAogCSAqIG1lbW9yeS4gIE1vc3QgY2hlY2tzIG9mIHRoZSBzaXplIG9mIHRoZSBoZWFw X2FyZWEgY29tcGFyZSBhZ2FpbnN0CkBAIC0yNTAzLDMyICsyNTg4LDQ5IEBACiAJICogaGVhcCBp cyBhbGxvY2F0ZWQuICAoT3IsIGluIHRoZSBjYWxjdWxhdGlvbiwgaWYgbGVzcyB0aGFuIDEvNHRo IGlzCiAJICogZnJlZSkKIAkgKi8KLQlpZiAoYnRvcCh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1F TV9GUkVFKSkgPAotCSAgICAoYnRvcCh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwg Vk1FTV9BTExPQykpID4+IDIpKQorCWlmICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVF KSA8CisJICAgICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwgVk1FTV9BTExPQykg Pj4gMikpIHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fdXNlZCwgdWludDY0X3QsCisJ CSAgICB2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSwgdWludDY0X3QsCisJCSAgICAo dm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+PiAyKTsKIAkJ cmV0dXJuICgxKTsKKwl9CiAjZW5kaWYKLSNlbHNlCS8qICFzdW4gKi8KLQlpZiAoa21lbV91c2Vk KCkgPiAoa21lbV9zaXplKCkgKiAzKSAvIDQpCisjaWZkZWYgc3VuCisJLyoKKwkgKiBJZiB6aW8g ZGF0YSBwYWdlcyBhcmUgYmVpbmcgYWxsb2NhdGVkIG91dCBvZiBhIHNlcGFyYXRlIGhlYXAgc2Vn bWVudCwKKwkgKiB0aGVuIGVuZm9yY2UgdGhhdCB0aGUgc2l6ZSBvZiBhdmFpbGFibGUgdm1lbSBm b3IgdGhpcyBhcmVuYSByZW1haW5zCisJICogYWJvdmUgYWJvdXQgMS8xNnRoIGZyZWUuCisJICoK KwkgKiBOb3RlOiBUaGUgMS8xNnRoIGFyZW5hIGZyZWUgcmVxdWlyZW1lbnQgd2FzIHB1dCBpbiBw bGFjZQorCSAqIHRvIGFnZ3Jlc3NpdmVseSBldmljdCBtZW1vcnkgZnJvbSB0aGUgYXJjIGluIG9y ZGVyIHRvIGF2b2lkCisJICogbWVtb3J5IGZyYWdtZW50YXRpb24gaXNzdWVzLgorCSAqLworCWlm ICh6aW9fYXJlbmEgIT0gTlVMTCAmJgorCSAgICB2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0ZS RUUpIDwKKwkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fQUxMT0MpID4+IDQpKQogCQly ZXR1cm4gKDEpOwogI2VuZGlmCS8qIHN1biAqLwotCi0jZWxzZQorI2Vsc2UJLyogX0tFUk5FTCAq LwogCWlmIChzcGFfZ2V0X3JhbmRvbSgxMDApID09IDApCiAJCXJldHVybiAoMSk7Ci0jZW5kaWYK KyNlbmRpZgkvKiBfS0VSTkVMICovCisJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9ubyk7CisK IAlyZXR1cm4gKDApOwogfQogCiBleHRlcm4ga21lbV9jYWNoZV90CSp6aW9fYnVmX2NhY2hlW107 CiBleHRlcm4ga21lbV9jYWNoZV90CSp6aW9fZGF0YV9idWZfY2FjaGVbXTsKIAotc3RhdGljIHZv aWQKK3N0YXRpYyB2b2lkIF9fdXNlZAogYXJjX2ttZW1fcmVhcF9ub3coYXJjX3JlY2xhaW1fc3Ry YXRlZ3lfdCBzdHJhdCkKIHsKIAlzaXplX3QJCQlpOwogCWttZW1fY2FjaGVfdAkJKnByZXZfY2Fj aGUgPSBOVUxMOwogCWttZW1fY2FjaGVfdAkJKnByZXZfZGF0YV9jYWNoZSA9IE5VTEw7CiAKKwlE VFJBQ0VfUFJPQkUoYXJjX19rbWVtX3JlYXBfc3RhcnQpOwogI2lmZGVmIF9LRVJORUwKIAlpZiAo YXJjX21ldGFfdXNlZCA+PSBhcmNfbWV0YV9saW1pdCkgewogCQkvKgpAQCAtMjU2NCw2ICsyNjY2 LDE2IEBACiAJfQogCWttZW1fY2FjaGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKIAlrbWVtX2NhY2hl X3JlYXBfbm93KGhkcl9jYWNoZSk7CisKKyNpZmRlZiBzdW4KKwkvKgorCSAqIEFzayB0aGUgdm1l bSBhcmVhbmEgdG8gcmVjbGFpbSB1bnVzZWQgbWVtb3J5IGZyb20gaXRzCisJICogcXVhbnR1bSBj YWNoZXMuCisJICovCisJaWYgKHppb19hcmVuYSAhPSBOVUxMICYmIHN0cmF0ID09IEFSQ19SRUNM QUlNX0FHR1IpCisJCXZtZW1fcWNhY2hlX3JlYXAoemlvX2FyZW5hKTsKKyNlbmRpZgorCURUUkFD RV9QUk9CRShhcmNfX2ttZW1fcmVhcF9lbmQpOwogfQogCiBzdGF0aWMgdm9pZApAQCAtMjU4MSw2 ICsyNjkzLDcgQEAKIAogCQkJaWYgKGFyY19ub19ncm93KSB7CiAJCQkJaWYgKGxhc3RfcmVjbGFp bSA9PSBBUkNfUkVDTEFJTV9DT05TKSB7CisJCQkJCURUUkFDRV9QUk9CRShhcmNfX3JlY2xhaW1f YWdncl9ub19ncm93KTsKIAkJCQkJbGFzdF9yZWNsYWltID0gQVJDX1JFQ0xBSU1fQUdHUjsKIAkJ CQl9IGVsc2UgewogCQkJCQlsYXN0X3JlY2xhaW0gPSBBUkNfUkVDTEFJTV9DT05TOwpAQCAtMjU4 OCw2ICsyNzAxLDcgQEAKIAkJCX0gZWxzZSB7CiAJCQkJYXJjX25vX2dyb3cgPSBUUlVFOwogCQkJ CWxhc3RfcmVjbGFpbSA9IEFSQ19SRUNMQUlNX0FHR1I7CisJCQkJRFRSQUNFX1BST0JFKGFyY19f cmVjbGFpbV9hZ2dyKTsKIAkJCQltZW1iYXJfcHJvZHVjZXIoKTsKIAkJCX0KIApAQCAtMjYwMiw2 ICsyNzE2LDcgQEAKIAkJCQkgKi8KIAkJCQlhcmNfbm9fZ3JvdyA9IFRSVUU7CiAJCQkJbGFzdF9y ZWNsYWltID0gQVJDX1JFQ0xBSU1fQUdHUjsKKwkJCQlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWlt X2FnZ3JfbmVlZGZyZWUpOwogCQkJfQogCQkJYXJjX2ttZW1fcmVhcF9ub3cobGFzdF9yZWNsYWlt KTsKIAkJCWFyY193YXJtID0gQl9UUlVFOwpAQCAtMjYxOCw2ICsyNzMzLDcgQEAKICNpZmRlZiBf S0VSTkVMCiAJCWlmIChuZWVkZnJlZSkgewogCQkJbmVlZGZyZWUgPSAwOworCQkJRFRSQUNFX1BS T0JFKGFyY19fY2xlYXJfbmVlZGZyZWUpOwogCQkJd2FrZXVwKCZuZWVkZnJlZSk7CiAJCX0KICNl bmRpZgpAQCAtMjY5Miw2ICsyODA4LDcgQEAKIAkgKiBjYWNoZSBzaXplLCBpbmNyZW1lbnQgdGhl IHRhcmdldCBjYWNoZSBzaXplCiAJICovCiAJaWYgKGFyY19zaXplID4gYXJjX2MgLSAoMlVMTCA8 PCBTUEFfTUFYQkxPQ0tTSElGVCkpIHsKKwkJRFRSQUNFX1BST0JFMShhcmNfX2luY19hZGFwdCwg aW50LCBieXRlcyk7CiAJCWF0b21pY19hZGRfNjQoJmFyY19jLCAoaW50NjRfdClieXRlcyk7CiAJ CWlmIChhcmNfYyA+IGFyY19jX21heCkKIAkJCWFyY19jID0gYXJjX2NfbWF4OwpAQCAtMjcxMywy MCArMjgzMCw2IEBACiAJaWYgKHR5cGUgPT0gQVJDX0JVRkNfTUVUQURBVEEgJiYgYXJjX21ldGFf dXNlZCA+PSBhcmNfbWV0YV9saW1pdCkKIAkJcmV0dXJuICgxKTsKIAotI2lmZGVmIHN1bgotI2lm ZGVmIF9LRVJORUwKLQkvKgotCSAqIElmIHppbyBkYXRhIHBhZ2VzIGFyZSBiZWluZyBhbGxvY2F0 ZWQgb3V0IG9mIGEgc2VwYXJhdGUgaGVhcCBzZWdtZW50LAotCSAqIHRoZW4gZW5mb3JjZSB0aGF0 IHRoZSBzaXplIG9mIGF2YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFyZWEgcmVtYWlucwotCSAqIGFi b3ZlIGFib3V0IDEvMzJuZCBmcmVlLgotCSAqLwotCWlmICh0eXBlID09IEFSQ19CVUZDX0RBVEEg JiYgemlvX2FyZW5hICE9IE5VTEwgJiYKLQkgICAgdm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9G UkVFKSA8Ci0JICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0FMTE9DKSA+PiA1KSkKLQkJ cmV0dXJuICgxKTsKLSNlbmRpZgotI2VuZGlmCS8qIHN1biAqLwotCiAJaWYgKGFyY19yZWNsYWlt X25lZWRlZCgpKQogCQlyZXR1cm4gKDEpOwogCkBAIC0zODg1LDIwICszOTg4LDE2IEBACiBhcmNf bWVtb3J5X3Rocm90dGxlKHVpbnQ2NF90IHJlc2VydmUsIHVpbnQ2NF90IHR4ZykKIHsKICNpZmRl ZiBfS0VSTkVMCi0JdWludDY0X3QgYXZhaWxhYmxlX21lbW9yeSA9Ci0JICAgIHB0b2EoKHVpbnRt YXhfdCljbnQudl9mcmVlX2NvdW50ICsgY250LnZfY2FjaGVfY291bnQpOworCXVpbnQ2NF90IGF2 YWlsYWJsZV9tZW1vcnkgPSBwdG9iKGZyZWVtZW0pOwogCXN0YXRpYyB1aW50NjRfdCBwYWdlX2xv YWQgPSAwOwogCXN0YXRpYyB1aW50NjRfdCBsYXN0X3R4ZyA9IDA7CiAKLSNpZmRlZiBzdW4KLSNp ZiBkZWZpbmVkKF9faTM4NikKKyNpZiBkZWZpbmVkKF9faTM4NikgfHwgIWRlZmluZWQoVU1BX01E X1NNQUxMX0FMTE9DKQogCWF2YWlsYWJsZV9tZW1vcnkgPQotCSAgICBNSU4oYXZhaWxhYmxlX21l bW9yeSwgdm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkpOworCSAgICBNSU4oYXZhaWxh YmxlX21lbW9yeSwgcHRvYih2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSkpOwogI2Vu ZGlmCi0jZW5kaWYJLyogc3VuICovCiAKLQlpZiAoY250LnZfZnJlZV9jb3VudCArIGNudC52X2Nh Y2hlX2NvdW50ID4KLQkgICAgKHVpbnQ2NF90KXBoeXNtZW0gKiBhcmNfbG90c2ZyZWVfcGVyY2Vu dCAvIDEwMCkKKwlpZiAoZnJlZW1lbSA+ICh1aW50NjRfdClwaHlzbWVtICogYXJjX2xvdHNmcmVl X3BlcmNlbnQgLyAxMDApCiAJCXJldHVybiAoMCk7CiAKIAlpZiAodHhnID4gbGFzdF90eGcpIHsK QEAgLTM5MTEsNyArNDAxMCw3IEBACiAJICogY29udGludWUgdG8gbGV0IHBhZ2Ugd3JpdGVzIG9j Y3VyIGFzIHF1aWNrbHkgYXMgcG9zc2libGUuCiAJICovCiAJaWYgKGN1cnByb2MgPT0gcGFnZXBy b2MpIHsKLQkJaWYgKHBhZ2VfbG9hZCA+IGF2YWlsYWJsZV9tZW1vcnkgLyA0KQorCQlpZiAocGFn ZV9sb2FkID4gTUFYKHB0b2IobWluZnJlZSksIGF2YWlsYWJsZV9tZW1vcnkpIC8gNCkKIAkJCXJl dHVybiAoU0VUX0VSUk9SKEVSRVNUQVJUKSk7CiAJCS8qIE5vdGU6IHJlc2VydmUgaXMgaW5mbGF0 ZWQsIHNvIHdlIGRlZmxhdGUgKi8KIAkJcGFnZV9sb2FkICs9IHJlc2VydmUgLyA4OwpAQCAtMzkz OSw4ICs0MDM4LDEwIEBACiAJaW50IGVycm9yOwogCXVpbnQ2NF90IGFub25fc2l6ZTsKIAotCWlm IChyZXNlcnZlID4gYXJjX2MvNCAmJiAhYXJjX25vX2dyb3cpCisJaWYgKHJlc2VydmUgPiBhcmNf Yy80ICYmICFhcmNfbm9fZ3JvdykgewogCQlhcmNfYyA9IE1JTihhcmNfY19tYXgsIHJlc2VydmUg KiA0KTsKKwkJRFRSQUNFX1BST0JFMShhcmNfX3NldF9yZXNlcnZlLCB1aW50NjRfdCwgYXJjX2Mp OworCX0KIAlpZiAocmVzZXJ2ZSA+IGFyY19jKQogCQlyZXR1cm4gKFNFVF9FUlJPUihFTk9NRU0p KTsKIApAQCAtMzk5NCw2ICs0MDk1LDcgQEAKIAltdXRleF9lbnRlcigmYXJjX2xvd21lbV9sb2Nr KTsKIAltdXRleF9lbnRlcigmYXJjX3JlY2xhaW1fdGhyX2xvY2spOwogCW5lZWRmcmVlID0gMTsK KwlEVFJBQ0VfUFJPQkUoYXJjX19uZWVkZnJlZSk7CiAJY3Zfc2lnbmFsKCZhcmNfcmVjbGFpbV90 aHJfY3YpOwogCiAJLyoKSW5kZXg6IHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2Nv bW1vbi9mcy96ZnMvZG11X3R4LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29udHJpYi9vcGVu c29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9kbXVfdHguYwkocmV2aXNpb24gMjcxNDM1KQorKysg c3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9kbXVfdHguYwko d29ya2luZyBjb3B5KQpAQCAtMTI3NSw2ICsxMjc1LDI3IEBACiAJICAgIHR4Z19ob3cgPT0gVFhH X1dBSVRFRCk7CiAJQVNTRVJUKCFkc2xfcG9vbF9zeW5jX2NvbnRleHQodHgtPnR4X3Bvb2wpKTsK IAorI2lmZGVmCV9LRVJORUwKKwkvKgorCSAqIEZpcnN0IGNoZWNrIHRvIHNlZSBpZiBkaXJ0eV9k YXRhX21heCBuZWVkcyBhZGp1c3RpbmcuICBEbyBub3QgYWxsb3cKKwkgKiB0aGUgZGlydHkgZGF0 YSBhbW91bnQgcGVyIHBvb2wgdG8gZXhjZWVkIGZyZWUsIG5vbi1zd2FwcGFibGUgUkFNLgorCSAq IFN1YmplY3QgdGhpcyB0byB0aGUgb3JpZ2luYWwgdGVzdCBvZiB0aGUgbWF4X21heCBsaW1pdCBh bmQgYSAKKwkgKiBtaW5pbXVtIG9mIDE2TUIuICBOZWNlc3Nhcnkgb24gRnJlZUJTRCBkdWUgdG8g QVJDIGJlaW5nIGFsbG93ZWQKKwkgKiB0byBwcmVzc3VyZSB0aGUgVk0gc3lzdGVtIHNvIGFzIHRv IHByZXZlbnQgdGhlIGFjcXVpc2l0aW9uIG9mIAorCSAqIGRpcnR5IEkvTyBidWZmZXJzIGZyb20g Y2F1c2luZyB0aGUgemZzX2lvIHRocmVhZHMgdG8gd2FpdCBvbgorCSAqIHRoZSBwYWdlZGFlbW9u IGZvciBhbiBhbGxvY2F0aW9uLgorCSAqLworCisgICAgICAgIHpmc19kaXJ0eV9kYXRhX21heCA9 IHB0b2IoY250LnZfZnJlZV9jb3VudCkgLSBwdG9iKGNudC52X2ZyZWVfbWluKTsKKyAgICAgICAg aWYgKHpmc19kaXJ0eV9kYXRhX21heCA8PSAxIDw8IDI0KSB7CisgICAgICAgICAgICAgICAgemZz X2RpcnR5X2RhdGFfbWF4ID0gMSA8PCAyNDsKKyAgICAgICAgfQorICAgICAgICB6ZnNfZGlydHlf ZGF0YV9tYXggPSBNSU4oemZzX2RpcnR5X2RhdGFfbWF4LCBwdG9iKHBoeXNtZW0pICoKKyAgICAg ICAgICAgICAgICB6ZnNfZGlydHlfZGF0YV9tYXhfcGVyY2VudCAvIDEwMCk7CisgICAgICAgIHpm c19kaXJ0eV9kYXRhX21heCA9IE1JTih6ZnNfZGlydHlfZGF0YV9tYXgsIHpmc19kaXJ0eV9kYXRh X21heF9tYXgpOworI2VuZGlmCS8qIF9LRVJORUwgKi8gCisJCisKIAkvKiBJZiB3ZSBtaWdodCB3 YWl0LCB3ZSBtdXN0IG5vdCBob2xkIHRoZSBjb25maWcgbG9jay4gKi8KIAlBU1NFUlQodHhnX2hv dyAhPSBUWEdfV0FJVCB8fCAhZHNsX3Bvb2xfY29uZmlnX2hlbGQodHgtPnR4X3Bvb2wpKTsKIApJ bmRleDogc3lzL3ZtL3ZtX3BhZ2VvdXQuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvdm0vdm1fcGFnZW91 dC5jCShyZXZpc2lvbiAyNzE0MzUpCisrKyBzeXMvdm0vdm1fcGFnZW91dC5jCSh3b3JraW5nIGNv cHkpCkBAIC03Niw2ICs3Niw3IEBACiBfX0ZCU0RJRCgiJEZyZWVCU0QkIik7CiAKICNpbmNsdWRl ICJvcHRfdm0uaCIKKyNpbmNsdWRlICJvcHRfa2R0cmFjZS5oIgogI2luY2x1ZGUgPHN5cy9wYXJh bS5oPgogI2luY2x1ZGUgPHN5cy9zeXN0bS5oPgogI2luY2x1ZGUgPHN5cy9rZXJuZWwuaD4KQEAg LTg5LDYgKzkwLDcgQEAKICNpbmNsdWRlIDxzeXMvcmFjY3QuaD4KICNpbmNsdWRlIDxzeXMvcmVz b3VyY2V2YXIuaD4KICNpbmNsdWRlIDxzeXMvc2NoZWQuaD4KKyNpbmNsdWRlIDxzeXMvc2R0Lmg+ CiAjaW5jbHVkZSA8c3lzL3NpZ25hbHZhci5oPgogI2luY2x1ZGUgPHN5cy9zbXAuaD4KICNpbmNs dWRlIDxzeXMvdm5vZGUuaD4KQEAgLTExNSwxMCArMTE3LDE0IEBACiAKIC8qIHRoZSBrZXJuZWwg cHJvY2VzcyAidm1fcGFnZW91dCIqLwogc3RhdGljIHZvaWQgdm1fcGFnZW91dCh2b2lkKTsKK3N0 YXRpYyB2b2lkIHZtX3BhZ2VvdXRfaW5pdCh2b2lkKTsKIHN0YXRpYyBpbnQgdm1fcGFnZW91dF9j bGVhbih2bV9wYWdlX3QpOwogc3RhdGljIHZvaWQgdm1fcGFnZW91dF9zY2FuKHN0cnVjdCB2bV9k b21haW4gKnZtZCwgaW50IHBhc3MpOwogc3RhdGljIHZvaWQgdm1fcGFnZW91dF9taWdodGJlX29v bShzdHJ1Y3Qgdm1fZG9tYWluICp2bWQsIGludCBwYXNzKTsKIAorU1lTSU5JVChwYWdlZGFlbW9u X2luaXQsIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX0ZJUlNULCB2bV9wYWdlb3V0X2lu aXQsCisgICAgTlVMTCk7CisKIHN0cnVjdCBwcm9jICpwYWdlcHJvYzsKIAogc3RhdGljIHN0cnVj dCBrcHJvY19kZXNjIHBhZ2Vfa3AgPSB7CkBAIC0xMjYsOSArMTMyLDEzIEBACiAJdm1fcGFnZW91 dCwKIAkmcGFnZXByb2MKIH07Ci1TWVNJTklUKHBhZ2VkYWVtb24sIFNJX1NVQl9LVEhSRUFEX1BB R0UsIFNJX09SREVSX0ZJUlNULCBrcHJvY19zdGFydCwKK1NZU0lOSVQocGFnZWRhZW1vbiwgU0lf U1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfU0VDT05ELCBrcHJvY19zdGFydCwKICAgICAmcGFn ZV9rcCk7CiAKK1NEVF9QUk9WSURFUl9ERUZJTkUodm0pOworU0RUX1BST0JFX0RFRklORSh2bSwg LCAsIHZtX19sb3dtZW1fY2FjaGUpOworU0RUX1BST0JFX0RFRklORSh2bSwgLCAsIHZtX19sb3dt ZW1fc2Nhbik7CisKICNpZiAhZGVmaW5lZChOT19TV0FQUElORykKIC8qIHRoZSBrZXJuZWwgcHJv Y2VzcyAidm1fZGFlbW9uIiovCiBzdGF0aWMgdm9pZCB2bV9kYWVtb24odm9pZCk7CkBAIC02NjMs NiArNjczLDcgQEAKIAkJICogbWF5IGFjcXVpcmUgbG9ja3MgYW5kL29yIHNsZWVwLCBzbyB0aGV5 IGNhbiBvbmx5IGJlIGludm9rZWQKIAkJICogd2hlbiAidHJpZXMiIGlzIGdyZWF0ZXIgdGhhbiB6 ZXJvLgogCQkgKi8KKwkJU0RUX1BST0JFMCh2bSwgLCAsIHZtX19sb3dtZW1fY2FjaGUpOwogCQlF VkVOVEhBTkRMRVJfSU5WT0tFKHZtX2xvd21lbSwgMCk7CiAKIAkJLyoKQEAgLTkwNCw3ICs5MTUs NyBAQAogICoJcGFzcyAxIC0gTW92ZSBpbmFjdGl2ZSB0byBjYWNoZSBvciBmcmVlCiAgKglwYXNz IDIgLSBMYXVuZGVyIGRpcnR5IHBhZ2VzCiAgKi8KLXN0YXRpYyB2b2lkCitzdGF0aWMgdm9pZCBf X3VzZWQKIHZtX3BhZ2VvdXRfc2NhbihzdHJ1Y3Qgdm1fZG9tYWluICp2bWQsIGludCBwYXNzKQog ewogCXZtX3BhZ2VfdCBtLCBuZXh0OwpAQCAtOTI1LDYgKzkzNiw3IEBACiAJCS8qCiAJCSAqIERl Y3JlYXNlIHJlZ2lzdGVyZWQgY2FjaGUgc2l6ZXMuCiAJCSAqLworCQlTRFRfUFJPQkUwKHZtLCAs ICwgdm1fX2xvd21lbV9zY2FuKTsKIAkJRVZFTlRIQU5ETEVSX0lOVk9LRSh2bV9sb3dtZW0sIDAp OwogCQkvKgogCQkgKiBXZSBkbyB0aGlzIGV4cGxpY2l0bHkgYWZ0ZXIgdGhlIGNhY2hlcyBoYXZl IGJlZW4KQEAgLTE2NTAsMTUgKzE2NjIsMTEgQEAKIH0KIAogLyoKLSAqCXZtX3BhZ2VvdXQgaXMg dGhlIGhpZ2ggbGV2ZWwgcGFnZW91dCBkYWVtb24uCisgKgl2bV9wYWdlb3V0X2luaXQgaW5pdGlh bGlzZXMgYmFzaWMgcGFnZW91dCBkYWVtb24gc2V0dGluZ3MuCiAgKi8KIHN0YXRpYyB2b2lkCi12 bV9wYWdlb3V0KHZvaWQpCit2bV9wYWdlb3V0X2luaXQodm9pZCkKIHsKLSNpZiBNQVhNRU1ET00g PiAxCi0JaW50IGVycm9yLCBpOwotI2VuZGlmCi0KIAkvKgogCSAqIEluaXRpYWxpemUgc29tZSBw YWdpbmcgcGFyYW1ldGVycy4KIAkgKi8KQEAgLTE3MDQsNyArMTcxMiwxOCBAQAogCS8qIFhYWCBk b2VzIG5vdCByZWFsbHkgYmVsb25nIGhlcmUgKi8KIAlpZiAodm1fcGFnZV9tYXhfd2lyZWQgPT0g MCkKIAkJdm1fcGFnZV9tYXhfd2lyZWQgPSBjbnQudl9mcmVlX2NvdW50IC8gMzsKK30KIAorLyoK KyAqICAgICB2bV9wYWdlb3V0IGlzIHRoZSBoaWdoIGxldmVsIHBhZ2VvdXQgZGFlbW9uLgorICov CitzdGF0aWMgdm9pZAordm1fcGFnZW91dCh2b2lkKQoreworI2lmIE1BWE1FTURPTSA+IDEKKwlp bnQgZXJyb3IsIGk7CisjZW5kaWYKKwogCXN3YXBfcGFnZXJfc3dhcF9pbml0KCk7CiAjaWYgTUFY TUVNRE9NID4gMQogCWZvciAoaSA9IDE7IGkgPCB2bV9uZG9tYWluczsgaSsrKSB7Cg== 147459 2014-09-19 01:45:02 +0000 2014-09-23 17:49:01 +0000 Replaces previous; results of further work with Steve patch-10.1-new text/plain 14810 karl SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MTgzOCkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTMzLDEzICsx MzMsNiBAQAogCXJldHVybiAoa21lbV9zaXplX3ZhbCk7CiB9CiAKLXVpbnQ2NF90Ci1rbWVtX3Vz ZWQodm9pZCkKLXsKLQotCXJldHVybiAodm1lbV9zaXplKGttZW1fYXJlbmEsIFZNRU1fQUxMT0Mp KTsKLX0KLQogc3RhdGljIGludAoga21lbV9zdGRfY29uc3RydWN0b3Iodm9pZCAqbWVtLCBpbnQg c2l6ZSBfX3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgaW50IGZsYWdzKQogewpJbmRleDogc3lzL2Nk ZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwv Y29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVtLmgJKHJldmlzaW9uIDI3MTgzOCkKKysrIHN5cy9j ZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCSh3b3JraW5nIGNvcHkpCkBAIC02Niw3 ICs2Niw2IEBACiB2b2lkICp6ZnNfa21lbV9hbGxvYyhzaXplX3Qgc2l6ZSwgaW50IGttZmxhZ3Mp Owogdm9pZCB6ZnNfa21lbV9mcmVlKHZvaWQgKmJ1Ziwgc2l6ZV90IHNpemUpOwogdWludDY0X3Qg a21lbV9zaXplKHZvaWQpOwotdWludDY0X3Qga21lbV91c2VkKHZvaWQpOwoga21lbV9jYWNoZV90 ICprbWVtX2NhY2hlX2NyZWF0ZShjaGFyICpuYW1lLCBzaXplX3QgYnVmc2l6ZSwgc2l6ZV90IGFs aWduLAogICAgIGludCAoKmNvbnN0cnVjdG9yKSh2b2lkICosIHZvaWQgKiwgaW50KSwgdm9pZCAo KmRlc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqKSwKICAgICB2b2lkICgqcmVjbGFpbSkodm9pZCAq KSBfX3VudXNlZCwgdm9pZCAqcHJpdmF0ZSwgdm1lbV90ICp2bXAsIGludCBjZmxhZ3MpOwpAQCAt NzgsNiArNzcsOSBAQAogaW50IGttZW1fZGVidWdnaW5nKHZvaWQpOwogdm9pZCAqY2FsbG9jKHNp emVfdCBuLCBzaXplX3Qgcyk7CiAKKyNkZWZpbmUJZnJlZW1lbQkJCQkoY250LnZfZnJlZV9jb3Vu dCArIGNudC52X2NhY2hlX2NvdW50KQorI2RlZmluZQltaW5mcmVlCQkJCWNudC52X2ZyZWVfbWlu CisjZGVmaW5lCWhlYXBfYXJlbmEJCQlrbWVtX2FyZW5hCiAjZGVmaW5lCWttZW1fYWxsb2Moc2l6 ZSwga21mbGFncykJemZzX2ttZW1fYWxsb2MoKHNpemUpLCAoa21mbGFncykpCiAjZGVmaW5lCWtt ZW1femFsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChzaXplKSwgKGttZmxhZ3Mp IHwgTV9aRVJPKQogI2RlZmluZQlrbWVtX2ZyZWUoYnVmLCBzaXplKQkJemZzX2ttZW1fZnJlZSgo YnVmKSwgKHNpemUpKQpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29t bW9uL2ZzL3pmcy9hcmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xh cmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzE4MzgpCisrKyBzeXMvY2Rk bC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3b3JraW5nIGNv cHkpCkBAIC0xMzgsNiArMTM4LDcgQEAKICNpbmNsdWRlIDxzeXMvc2R0Lmg+CiAKICNpbmNsdWRl IDx2bS92bV9wYWdlb3V0Lmg+CisjaW5jbHVkZSA8bWFjaGluZS92bXBhcmFtLmg+CiAKICNpZmRl ZiBpbGx1bW9zCiAjaWZuZGVmIF9LRVJORUwKQEAgLTE5Myw5ICsxOTQsNiBAQAogICovCiBzdGF0 aWMgYm9vbGVhbl90IGFyY193YXJtOwogCi0vKgotICogVGhlc2UgdHVuYWJsZXMgYXJlIGZvciBw ZXJmb3JtYW5jZSBhbmFseXNpcy4KLSAqLwogdWludDY0X3QgemZzX2FyY19tYXg7CiB1aW50NjRf dCB6ZnNfYXJjX21pbjsKIHVpbnQ2NF90IHpmc19hcmNfbWV0YV9saW1pdCA9IDA7CkBAIC0yMDQs NyArMjAyLDIxIEBACiBpbnQgemZzX2FyY19wX21pbl9zaGlmdCA9IDA7CiBpbnQgemZzX2Rpc2Fi bGVfZHVwX2V2aWN0aW9uID0gMDsKIHVpbnQ2NF90IHpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUg PSA4ICogMTAyNDsgLyogOEtCICovCit1X2ludCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gKDEgPDwg MTYpOyAvKiBkZWZhdWx0IGJlZm9yZSBwYWdlZGFlbW9uIGluaXQgb25seSAqLworaW50IHpmc19h cmNfcmVjbGFpbV9jYWNoZV9mcmVlID0gMTsKIAorc3RhdGljIGludCBzeXNjdGxfdmZzX3pmc19h cmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CisKKyNpZmRlZiBfS0VSTkVMCitz dGF0aWMgdm9pZAorYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQor eworCisJemZzX2FyY19mcmVlX3RhcmdldCA9ICh2bV9wYWdlb3V0X3dha2V1cF90aHJlc2ggKyAo KGNudC52X2ZyZWVfdGFyZ2V0IC0gdm1fcGFnZW91dF93YWtldXBfdGhyZXNoKSAvIDIpKTsKK30K K1NZU0lOSVQoYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09S REVSX0FOWSwKKyAgICBhcmNfZnJlZV90YXJnZXRfaW5pdCwgTlVMTCk7CisKIFRVTkFCTEVfUVVB RCgidmZzLnpmcy5hcmNfbWF4IiwgJnpmc19hcmNfbWF4KTsKIFRVTkFCTEVfUVVBRCgidmZzLnpm cy5hcmNfbWluIiwgJnpmc19hcmNfbWluKTsKIFRVTkFCTEVfUVVBRCgidmZzLnpmcy5hcmNfbWV0 YV9saW1pdCIsICZ6ZnNfYXJjX21ldGFfbGltaXQpOwpAQCAtMjE3LDcgKzIyOSw0MCBAQAogU1lT Q1RMX1VRVUFEKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCBDVExG TEFHX1JEVFVOLAogICAgICZ6ZnNfYXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCAwLAogICAgICJBUkMg YXZlcmFnZSBibG9ja3NpemUiKTsKK1NZU0NUTF9JTlQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNf cmVjbGFpbV9jYWNoZV9mcmVlLCBDVExGTEFHX1JXVFVOLAorICAgICZ6ZnNfYXJjX3JlY2xhaW1f Y2FjaGVfZnJlZSwgMCwKKyAgICAiQVJDIHRyZWF0cyBjYWNoZWQgcGFnZXMgYXMgZnJlZSBibG9j a3NpemUiKTsKKy8qCisgKiBXZSBkb24ndCBoYXZlIGEgdHVuYWJsZSBmb3IgYXJjX2ZyZWVfdGFy Z2V0IGR1ZSB0byB0aGUgZGVwZW5kZW5jeSBvbgorICogcGFnZWRhZW1vbiBpbml0aWFsaXNhdGlv bi4KKyAqLworU1lTQ1RMX1BST0MoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfZnJlZV90YXJnZXQs CisgICAgQ1RMVFlQRV9VSU5UIHwgQ1RMRkxBR19NUFNBRkUgfCBDVExGTEFHX1JXLCAwLCBzaXpl b2YodV9pbnQpLAorICAgIHN5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldCwgIklVIiwKKyAg ICAiRGVzaXJlZCBudW1iZXIgb2YgZnJlZSBwYWdlcyBiZWxvdyB3aGljaCBBUkMgdHJpZ2dlcnMg cmVjbGFpbSIpOwogCitzdGF0aWMgaW50CitzeXNjdGxfdmZzX3pmc19hcmNfZnJlZV90YXJnZXQo U1lTQ1RMX0hBTkRMRVJfQVJHUykKK3sKKwl1X2ludCB2YWw7CisJaW50IGVycjsKKworCXZhbCA9 IHpmc19hcmNfZnJlZV90YXJnZXQ7CisJZXJyID0gc3lzY3RsX2hhbmRsZV9pbnQob2lkcCwgJnZh bCwgMCwgcmVxKTsKKwlpZiAoZXJyICE9IDAgfHwgcmVxLT5uZXdwdHIgPT0gTlVMTCkKKwkJcmV0 dXJuIChlcnIpOworCisJaWYgKHZhbCA8IG1pbmZyZWUpCisJCXJldHVybiAoRUlOVkFMKTsKKwlp ZiAodmFsID4gY250LnZfcGFnZV9jb3VudCkKKwkJcmV0dXJuIChFSU5WQUwpOworCisJemZzX2Fy Y19mcmVlX3RhcmdldCA9IHZhbDsKKworCXJldHVybiAoMCk7Cit9CisjZW5kaWYKKwogLyoKICAq IE5vdGUgdGhhdCBidWZmZXJzIGNhbiBiZSBpbiBvbmUgb2YgNiBzdGF0ZXM6CiAgKglBUkNfYW5v bgktIGFub255bW91cyAoZGlzY3Vzc2VkIGJlbG93KQpAQCAtMjQyMSw2ICsyNDY2LDcgQEAKIHZv aWQKIGFyY19zaHJpbmsodm9pZCkKIHsKKwogCWlmIChhcmNfYyA+IGFyY19jX21pbikgewogCQl1 aW50NjRfdCB0b19mcmVlOwogCkBAIC0yNDI5LDYgKzI0NzUsOSBAQAogI2Vsc2UKIAkJdG9fZnJl ZSA9IGFyY19jID4+IGFyY19zaHJpbmtfc2hpZnQ7CiAjZW5kaWYKKwkJRFRSQUNFX1BST0JFNChh cmNfX3NocmluaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRfdCwKKwkJCWFyY19jX21pbiwgdWlu dDY0X3QsIGFyY19wLCB1aW50NjRfdCwgdG9fZnJlZSk7CisKIAkJaWYgKGFyY19jID4gYXJjX2Nf bWluICsgdG9fZnJlZSkKIAkJCWF0b21pY19hZGRfNjQoJmFyY19jLCAtdG9fZnJlZSk7CiAJCWVs c2UKQEAgLTI0MzksMTIgKzI0ODgsMTkgQEAKIAkJCWFyY19jID0gTUFYKGFyY19zaXplLCBhcmNf Y19taW4pOwogCQlpZiAoYXJjX3AgPiBhcmNfYykKIAkJCWFyY19wID0gKGFyY19jID4+IDEpOwor CisJCURUUkFDRV9QUk9CRTIoYXJjX19zaHJ1bmssIHVpbnQ2NF90LCBhcmNfYywgdWludDY0X3Qs CisJCQlhcmNfcCk7CisKIAkJQVNTRVJUKGFyY19jID49IGFyY19jX21pbik7CiAJCUFTU0VSVCgo aW50NjRfdClhcmNfcCA+PSAwKTsKIAl9CiAKLQlpZiAoYXJjX3NpemUgPiBhcmNfYykKKwlpZiAo YXJjX3NpemUgPiBhcmNfYykgeworCQlEVFJBQ0VfUFJPQkUyKGFyY19fc2hyaW5rX2FkanVzdCwg dWludDY0X3QsIGFyY19zaXplLAorCQkJdWludDY0X3QsIGFyY19jKTsKIAkJYXJjX2FkanVzdCgp OworCX0KIH0KIAogc3RhdGljIGludCBuZWVkZnJlZSA9IDA7CkBAIC0yNDUyLDE4ICsyNTA4LDM1 IEBACiBzdGF0aWMgaW50CiBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkKIHsKKwl1X2ludCBmbTsK IAogI2lmZGVmIF9LRVJORUwKKwlpZiAoYXJjX3NpemUgPD0gYXJjX2NfbWluKSB7CisJCURUUkFD RV9QUk9CRTIoYXJjX19yZWNsYWltX21pbiwgdWludDY0X3QsIGFyY19zaXplLAorCQkgICAgdWlu dDY0X3QsIGFyY19jX21pbik7CisJCXJldHVybiAoMCk7CisJfQogCi0JaWYgKG5lZWRmcmVlKQor CWlmIChuZWVkZnJlZSkgeworCQlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX25lZWRmcmVlKTsK IAkJcmV0dXJuICgxKTsKKwl9CiAKIAkvKgogCSAqIENvb3BlcmF0ZSB3aXRoIHBhZ2VkYWVtb24g d2hlbiBpdCdzIHRpbWUgZm9yIGl0IHRvIHNjYW4KIAkgKiBhbmQgcmVjbGFpbSBzb21lIHBhZ2Vz LgogCSAqLwotCWlmICh2bV9wYWdpbmdfbmVlZGVkKCkpCisJaWYgKHpmc19hcmNfcmVjbGFpbV9j YWNoZV9mcmVlID09IDApCisJCWZtID0gY250LnZfZnJlZV9jb3VudDsKKwllbHNlCisJCWZtID0g ZnJlZW1lbTsKKworCWlmIChmbSA8IHpmc19hcmNfZnJlZV90YXJnZXQpIHsKKwkJRFRSQUNFX1BS T0JFMyhhcmNfX3JlY2xhaW1fZnJlZW1lbSwgdWludDY0X3QsCisJCSAgICBmbSwgdWludDY0X3Qs IHpmc19hcmNfZnJlZV90YXJnZXQsCisJCSAgICBpbnQsIHpmc19hcmNfcmVjbGFpbV9jYWNoZV9m cmVlKTsKIAkJcmV0dXJuICgxKTsKKwl9CiAKICNpZmRlZiBzdW4KIAkvKgpAQCAtMjQ5MSw4ICsy NTY0LDE5IEBACiAJaWYgKGF2YWlscm1lbSA8IHN3YXBmc19taW5mcmVlICsgc3dhcGZzX3Jlc2Vy dmUgKyBleHRyYSkKIAkJcmV0dXJuICgxKTsKIAotI2lmIGRlZmluZWQoX19pMzg2KQogCS8qCisJ ICogQ2hlY2sgdGhhdCB3ZSBoYXZlIGVub3VnaCBhdmFpbHJtZW0gdGhhdCBtZW1vcnkgbG9ja2lu ZyAoZS5nLiwgdmlhCisJICogbWxvY2soM0MpIG9yIG1lbWNudGwoMikpIGNhbiBzdGlsbCBzdWNj ZWVkLiAgKHBhZ2VzX3BwX21heGltdW0KKwkgKiBzdG9yZXMgdGhlIG51bWJlciBvZiBwYWdlcyB0 aGF0IGNhbm5vdCBiZSBsb2NrZWQ7IHdoZW4gYXZhaWxybWVtCisJICogZHJvcHMgYmVsb3cgcGFn ZXNfcHBfbWF4aW11bSwgcGFnZSBsb2NraW5nIG1lY2hhbmlzbXMgc3VjaCBhcworCSAqIHBhZ2Vf cHBfbG9jaygpIHdpbGwgZmFpbC4pCisJICovCisJaWYgKGF2YWlscm1lbSA8PSBwYWdlc19wcF9t YXhpbXVtKQorCQlyZXR1cm4gKDEpOworCisjZW5kaWYJLyogc3VuICovCisjaWYgZGVmaW5lZChf X2kzODYpIHx8ICFkZWZpbmVkKFVNQV9NRF9TTUFMTF9BTExPQykKKwkvKgogCSAqIElmIHdlJ3Jl IG9uIGFuIGkzODYgcGxhdGZvcm0sIGl0J3MgcG9zc2libGUgdGhhdCB3ZSdsbCBleGhhdXN0IHRo ZQogCSAqIGtlcm5lbCBoZWFwIHNwYWNlIGJlZm9yZSB3ZSBldmVyIHJ1biBvdXQgb2YgYXZhaWxh YmxlIHBoeXNpY2FsCiAJICogbWVtb3J5LiAgTW9zdCBjaGVja3Mgb2YgdGhlIHNpemUgb2YgdGhl IGhlYXBfYXJlYSBjb21wYXJlIGFnYWluc3QKQEAgLTI1MDMsMzIgKzI1ODcsNDkgQEAKIAkgKiBo ZWFwIGlzIGFsbG9jYXRlZC4gIChPciwgaW4gdGhlIGNhbGN1bGF0aW9uLCBpZiBsZXNzIHRoYW4g MS80dGggaXMKIAkgKiBmcmVlKQogCSAqLwotCWlmIChidG9wKHZtZW1fc2l6ZShoZWFwX2FyZW5h LCBWTUVNX0ZSRUUpKSA8Ci0JICAgIChidG9wKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZS RUUgfCBWTUVNX0FMTE9DKSkgPj4gMikpCisJaWYgKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVN X0ZSRUUpIDwKKwkgICAgKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUgfCBWTUVNX0FM TE9DKSA+PiAyKSkgeworCQlEVFJBQ0VfUFJPQkUyKGFyY19fcmVjbGFpbV91c2VkLCB1aW50NjRf dCwKKwkJICAgIHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpLCB1aW50NjRfdCwKKwkJ ICAgICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwgVk1FTV9BTExPQykpID4+IDIp OwogCQlyZXR1cm4gKDEpOworCX0KICNlbmRpZgotI2Vsc2UJLyogIXN1biAqLwotCWlmIChrbWVt X3VzZWQoKSA+IChrbWVtX3NpemUoKSAqIDMpIC8gNCkKKyNpZmRlZiBzdW4KKwkvKgorCSAqIElm IHppbyBkYXRhIHBhZ2VzIGFyZSBiZWluZyBhbGxvY2F0ZWQgb3V0IG9mIGEgc2VwYXJhdGUgaGVh cCBzZWdtZW50LAorCSAqIHRoZW4gZW5mb3JjZSB0aGF0IHRoZSBzaXplIG9mIGF2YWlsYWJsZSB2 bWVtIGZvciB0aGlzIGFyZW5hIHJlbWFpbnMKKwkgKiBhYm92ZSBhYm91dCAxLzE2dGggZnJlZS4K KwkgKgorCSAqIE5vdGU6IFRoZSAxLzE2dGggYXJlbmEgZnJlZSByZXF1aXJlbWVudCB3YXMgcHV0 IGluIHBsYWNlCisJICogdG8gYWdncmVzc2l2ZWx5IGV2aWN0IG1lbW9yeSBmcm9tIHRoZSBhcmMg aW4gb3JkZXIgdG8gYXZvaWQKKwkgKiBtZW1vcnkgZnJhZ21lbnRhdGlvbiBpc3N1ZXMuCisJICov CisJaWYgKHppb19hcmVuYSAhPSBOVUxMICYmCisJICAgIHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZN RU1fRlJFRSkgPAorCSAgICAodm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9BTExPQykgPj4gNCkp CiAJCXJldHVybiAoMSk7CiAjZW5kaWYJLyogc3VuICovCi0KLSNlbHNlCisjZWxzZQkvKiBfS0VS TkVMICovCiAJaWYgKHNwYV9nZXRfcmFuZG9tKDEwMCkgPT0gMCkKIAkJcmV0dXJuICgxKTsKLSNl bmRpZgorI2VuZGlmCS8qIF9LRVJORUwgKi8KKwlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX25v KTsKKwogCXJldHVybiAoMCk7CiB9CiAKIGV4dGVybiBrbWVtX2NhY2hlX3QJKnppb19idWZfY2Fj aGVbXTsKIGV4dGVybiBrbWVtX2NhY2hlX3QJKnppb19kYXRhX2J1Zl9jYWNoZVtdOwogCi1zdGF0 aWMgdm9pZAorc3RhdGljIHZvaWQgX191c2VkCiBhcmNfa21lbV9yZWFwX25vdyhhcmNfcmVjbGFp bV9zdHJhdGVneV90IHN0cmF0KQogewogCXNpemVfdAkJCWk7CiAJa21lbV9jYWNoZV90CQkqcHJl dl9jYWNoZSA9IE5VTEw7CiAJa21lbV9jYWNoZV90CQkqcHJldl9kYXRhX2NhY2hlID0gTlVMTDsK IAorCURUUkFDRV9QUk9CRShhcmNfX2ttZW1fcmVhcF9zdGFydCk7CiAjaWZkZWYgX0tFUk5FTAog CWlmIChhcmNfbWV0YV91c2VkID49IGFyY19tZXRhX2xpbWl0KSB7CiAJCS8qCkBAIC0yNTY0LDYg KzI2NjUsMTYgQEAKIAl9CiAJa21lbV9jYWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOwogCWttZW1f Y2FjaGVfcmVhcF9ub3coaGRyX2NhY2hlKTsKKworI2lmZGVmIHN1bgorCS8qCisJICogQXNrIHRo ZSB2bWVtIGFyZWFuYSB0byByZWNsYWltIHVudXNlZCBtZW1vcnkgZnJvbSBpdHMKKwkgKiBxdWFu dHVtIGNhY2hlcy4KKwkgKi8KKwlpZiAoemlvX2FyZW5hICE9IE5VTEwgJiYgc3RyYXQgPT0gQVJD X1JFQ0xBSU1fQUdHUikKKwkJdm1lbV9xY2FjaGVfcmVhcCh6aW9fYXJlbmEpOworI2VuZGlmCisJ RFRSQUNFX1BST0JFKGFyY19fa21lbV9yZWFwX2VuZCk7CiB9CiAKIHN0YXRpYyB2b2lkCkBAIC0y NTgxLDYgKzI2OTIsNyBAQAogCiAJCQlpZiAoYXJjX25vX2dyb3cpIHsKIAkJCQlpZiAobGFzdF9y ZWNsYWltID09IEFSQ19SRUNMQUlNX0NPTlMpIHsKKwkJCQkJRFRSQUNFX1BST0JFKGFyY19fcmVj bGFpbV9hZ2dyX25vX2dyb3cpOwogCQkJCQlsYXN0X3JlY2xhaW0gPSBBUkNfUkVDTEFJTV9BR0dS OwogCQkJCX0gZWxzZSB7CiAJCQkJCWxhc3RfcmVjbGFpbSA9IEFSQ19SRUNMQUlNX0NPTlM7CkBA IC0yNTg4LDYgKzI3MDAsNyBAQAogCQkJfSBlbHNlIHsKIAkJCQlhcmNfbm9fZ3JvdyA9IFRSVUU7 CiAJCQkJbGFzdF9yZWNsYWltID0gQVJDX1JFQ0xBSU1fQUdHUjsKKwkJCQlEVFJBQ0VfUFJPQkUo YXJjX19yZWNsYWltX2FnZ3IpOwogCQkJCW1lbWJhcl9wcm9kdWNlcigpOwogCQkJfQogCkBAIC0y NjAyLDYgKzI3MTUsNyBAQAogCQkJCSAqLwogCQkJCWFyY19ub19ncm93ID0gVFJVRTsKIAkJCQls YXN0X3JlY2xhaW0gPSBBUkNfUkVDTEFJTV9BR0dSOworCQkJCURUUkFDRV9QUk9CRShhcmNfX3Jl Y2xhaW1fYWdncl9uZWVkZnJlZSk7CiAJCQl9CiAJCQlhcmNfa21lbV9yZWFwX25vdyhsYXN0X3Jl Y2xhaW0pOwogCQkJYXJjX3dhcm0gPSBCX1RSVUU7CkBAIC0yNjE4LDYgKzI3MzIsNyBAQAogI2lm ZGVmIF9LRVJORUwKIAkJaWYgKG5lZWRmcmVlKSB7CiAJCQluZWVkZnJlZSA9IDA7CisJCQlEVFJB Q0VfUFJPQkUoYXJjX19jbGVhcl9uZWVkZnJlZSk7CiAJCQl3YWtldXAoJm5lZWRmcmVlKTsKIAkJ fQogI2VuZGlmCkBAIC0yNjkyLDYgKzI4MDcsNyBAQAogCSAqIGNhY2hlIHNpemUsIGluY3JlbWVu dCB0aGUgdGFyZ2V0IGNhY2hlIHNpemUKIAkgKi8KIAlpZiAoYXJjX3NpemUgPiBhcmNfYyAtICgy VUxMIDw8IFNQQV9NQVhCTE9DS1NISUZUKSkgeworCQlEVFJBQ0VfUFJPQkUxKGFyY19faW5jX2Fk YXB0LCBpbnQsIGJ5dGVzKTsKIAkJYXRvbWljX2FkZF82NCgmYXJjX2MsIChpbnQ2NF90KWJ5dGVz KTsKIAkJaWYgKGFyY19jID4gYXJjX2NfbWF4KQogCQkJYXJjX2MgPSBhcmNfY19tYXg7CkBAIC0y NzEzLDIwICsyODI5LDYgQEAKIAlpZiAodHlwZSA9PSBBUkNfQlVGQ19NRVRBREFUQSAmJiBhcmNf bWV0YV91c2VkID49IGFyY19tZXRhX2xpbWl0KQogCQlyZXR1cm4gKDEpOwogCi0jaWZkZWYgc3Vu Ci0jaWZkZWYgX0tFUk5FTAotCS8qCi0JICogSWYgemlvIGRhdGEgcGFnZXMgYXJlIGJlaW5nIGFs bG9jYXRlZCBvdXQgb2YgYSBzZXBhcmF0ZSBoZWFwIHNlZ21lbnQsCi0JICogdGhlbiBlbmZvcmNl IHRoYXQgdGhlIHNpemUgb2YgYXZhaWxhYmxlIHZtZW0gZm9yIHRoaXMgYXJlYSByZW1haW5zCi0J ICogYWJvdmUgYWJvdXQgMS8zMm5kIGZyZWUuCi0JICovCi0JaWYgKHR5cGUgPT0gQVJDX0JVRkNf REFUQSAmJiB6aW9fYXJlbmEgIT0gTlVMTCAmJgotCSAgICB2bWVtX3NpemUoemlvX2FyZW5hLCBW TUVNX0ZSRUUpIDwKLQkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fQUxMT0MpID4+IDUp KQotCQlyZXR1cm4gKDEpOwotI2VuZGlmCi0jZW5kaWYJLyogc3VuICovCi0KIAlpZiAoYXJjX3Jl Y2xhaW1fbmVlZGVkKCkpCiAJCXJldHVybiAoMSk7CiAKQEAgLTM4ODUsMjAgKzM5ODcsMTYgQEAK IGFyY19tZW1vcnlfdGhyb3R0bGUodWludDY0X3QgcmVzZXJ2ZSwgdWludDY0X3QgdHhnKQogewog I2lmZGVmIF9LRVJORUwKLQl1aW50NjRfdCBhdmFpbGFibGVfbWVtb3J5ID0KLQkgICAgcHRvYSgo dWludG1heF90KWNudC52X2ZyZWVfY291bnQgKyBjbnQudl9jYWNoZV9jb3VudCk7CisJdWludDY0 X3QgYXZhaWxhYmxlX21lbW9yeSA9IHB0b2IoZnJlZW1lbSk7CiAJc3RhdGljIHVpbnQ2NF90IHBh Z2VfbG9hZCA9IDA7CiAJc3RhdGljIHVpbnQ2NF90IGxhc3RfdHhnID0gMDsKIAotI2lmZGVmIHN1 bgotI2lmIGRlZmluZWQoX19pMzg2KQorI2lmIGRlZmluZWQoX19pMzg2KSB8fCAhZGVmaW5lZChV TUFfTURfU01BTExfQUxMT0MpCiAJYXZhaWxhYmxlX21lbW9yeSA9Ci0JICAgIE1JTihhdmFpbGFi bGVfbWVtb3J5LCB2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSk7CisJICAgIE1JTihh dmFpbGFibGVfbWVtb3J5LCBwdG9iKHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpKSk7 CiAjZW5kaWYKLSNlbmRpZgkvKiBzdW4gKi8KIAotCWlmIChjbnQudl9mcmVlX2NvdW50ICsgY250 LnZfY2FjaGVfY291bnQgPgotCSAgICAodWludDY0X3QpcGh5c21lbSAqIGFyY19sb3RzZnJlZV9w ZXJjZW50IC8gMTAwKQorCWlmIChmcmVlbWVtID4gKHVpbnQ2NF90KXBoeXNtZW0gKiBhcmNfbG90 c2ZyZWVfcGVyY2VudCAvIDEwMCkKIAkJcmV0dXJuICgwKTsKIAogCWlmICh0eGcgPiBsYXN0X3R4 ZykgewpAQCAtMzkxMSw3ICs0MDA5LDcgQEAKIAkgKiBjb250aW51ZSB0byBsZXQgcGFnZSB3cml0 ZXMgb2NjdXIgYXMgcXVpY2tseSBhcyBwb3NzaWJsZS4KIAkgKi8KIAlpZiAoY3VycHJvYyA9PSBw YWdlcHJvYykgewotCQlpZiAocGFnZV9sb2FkID4gYXZhaWxhYmxlX21lbW9yeSAvIDQpCisJCWlm IChwYWdlX2xvYWQgPiBNQVgocHRvYihtaW5mcmVlKSwgYXZhaWxhYmxlX21lbW9yeSkgLyA0KQog CQkJcmV0dXJuIChTRVRfRVJST1IoRVJFU1RBUlQpKTsKIAkJLyogTm90ZTogcmVzZXJ2ZSBpcyBp bmZsYXRlZCwgc28gd2UgZGVmbGF0ZSAqLwogCQlwYWdlX2xvYWQgKz0gcmVzZXJ2ZSAvIDg7CkBA IC0zOTM5LDggKzQwMzcsMTAgQEAKIAlpbnQgZXJyb3I7CiAJdWludDY0X3QgYW5vbl9zaXplOwog Ci0JaWYgKHJlc2VydmUgPiBhcmNfYy80ICYmICFhcmNfbm9fZ3JvdykKKwlpZiAocmVzZXJ2ZSA+ IGFyY19jLzQgJiYgIWFyY19ub19ncm93KSB7CiAJCWFyY19jID0gTUlOKGFyY19jX21heCwgcmVz ZXJ2ZSAqIDQpOworCQlEVFJBQ0VfUFJPQkUxKGFyY19fc2V0X3Jlc2VydmUsIHVpbnQ2NF90LCBh cmNfYyk7CisJfQogCWlmIChyZXNlcnZlID4gYXJjX2MpCiAJCXJldHVybiAoU0VUX0VSUk9SKEVO T01FTSkpOwogCkBAIC0zOTk0LDYgKzQwOTQsNyBAQAogCW11dGV4X2VudGVyKCZhcmNfbG93bWVt X2xvY2spOwogCW11dGV4X2VudGVyKCZhcmNfcmVjbGFpbV90aHJfbG9jayk7CiAJbmVlZGZyZWUg PSAxOworCURUUkFDRV9QUk9CRShhcmNfX25lZWRmcmVlKTsKIAljdl9zaWduYWwoJmFyY19yZWNs YWltX3Rocl9jdik7CiAKIAkvKgpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91 dHMvY29tbW9uL2ZzL3pmcy96aW8uYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29w ZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3ppby5jCShyZXZpc2lvbiAyNzE4MzgpCisrKyBz eXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3ppby5jCSh3b3Jr aW5nIGNvcHkpCkBAIC00Myw3ICs0Myw3IEBACiBTWVNDVExfREVDTChfdmZzX3pmcyk7CiBTWVND VExfTk9ERShfdmZzX3pmcywgT0lEX0FVVE8sIHppbywgQ1RMRkxBR19SVywgMCwgIlpGUyBaSU8i KTsKICNpZiBkZWZpbmVkKF9fYW1kNjRfXykKLXN0YXRpYyBpbnQgemlvX3VzZV91bWEgPSAxOwor c3RhdGljIGludCB6aW9fdXNlX3VtYSA9IDA7CS8qIEtEIDIwMTQtMDktMTggLSBVTUEgb2ZmOyBi cm9rZW4hICovCiAjZWxzZQogc3RhdGljIGludCB6aW9fdXNlX3VtYSA9IDA7CiAjZW5kaWYKSW5k ZXg6IHN5cy92bS92bV9wYWdlb3V0LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL3ZtL3ZtX3BhZ2VvdXQu YwkocmV2aXNpb24gMjcxODM4KQorKysgc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkod29ya2luZyBjb3B5 KQpAQCAtNzYsNiArNzYsNyBAQAogX19GQlNESUQoIiRGcmVlQlNEJCIpOwogCiAjaW5jbHVkZSAi b3B0X3ZtLmgiCisjaW5jbHVkZSAib3B0X2tkdHJhY2UuaCIKICNpbmNsdWRlIDxzeXMvcGFyYW0u aD4KICNpbmNsdWRlIDxzeXMvc3lzdG0uaD4KICNpbmNsdWRlIDxzeXMva2VybmVsLmg+CkBAIC04 OSw2ICs5MCw3IEBACiAjaW5jbHVkZSA8c3lzL3JhY2N0Lmg+CiAjaW5jbHVkZSA8c3lzL3Jlc291 cmNldmFyLmg+CiAjaW5jbHVkZSA8c3lzL3NjaGVkLmg+CisjaW5jbHVkZSA8c3lzL3NkdC5oPgog I2luY2x1ZGUgPHN5cy9zaWduYWx2YXIuaD4KICNpbmNsdWRlIDxzeXMvc21wLmg+CiAjaW5jbHVk ZSA8c3lzL3Zub2RlLmg+CkBAIC0xMTUsMTAgKzExNywxNCBAQAogCiAvKiB0aGUga2VybmVsIHBy b2Nlc3MgInZtX3BhZ2VvdXQiKi8KIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXQodm9pZCk7CitzdGF0 aWMgdm9pZCB2bV9wYWdlb3V0X2luaXQodm9pZCk7CiBzdGF0aWMgaW50IHZtX3BhZ2VvdXRfY2xl YW4odm1fcGFnZV90KTsKIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXRfc2NhbihzdHJ1Y3Qgdm1fZG9t YWluICp2bWQsIGludCBwYXNzKTsKIHN0YXRpYyB2b2lkIHZtX3BhZ2VvdXRfbWlnaHRiZV9vb20o c3RydWN0IHZtX2RvbWFpbiAqdm1kLCBpbnQgcGFzcyk7CiAKK1NZU0lOSVQocGFnZWRhZW1vbl9p bml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9GSVJTVCwgdm1fcGFnZW91dF9pbml0 LAorICAgIE5VTEwpOworCiBzdHJ1Y3QgcHJvYyAqcGFnZXByb2M7CiAKIHN0YXRpYyBzdHJ1Y3Qg a3Byb2NfZGVzYyBwYWdlX2twID0gewpAQCAtMTI2LDkgKzEzMiwxMyBAQAogCXZtX3BhZ2VvdXQs CiAJJnBhZ2Vwcm9jCiB9OwotU1lTSU5JVChwYWdlZGFlbW9uLCBTSV9TVUJfS1RIUkVBRF9QQUdF LCBTSV9PUkRFUl9GSVJTVCwga3Byb2Nfc3RhcnQsCitTWVNJTklUKHBhZ2VkYWVtb24sIFNJX1NV Ql9LVEhSRUFEX1BBR0UsIFNJX09SREVSX1NFQ09ORCwga3Byb2Nfc3RhcnQsCiAgICAgJnBhZ2Vf a3ApOwogCitTRFRfUFJPVklERVJfREVGSU5FKHZtKTsKK1NEVF9QUk9CRV9ERUZJTkUodm0sICwg LCB2bV9fbG93bWVtX2NhY2hlKTsKK1NEVF9QUk9CRV9ERUZJTkUodm0sICwgLCB2bV9fbG93bWVt X3NjYW4pOworCiAjaWYgIWRlZmluZWQoTk9fU1dBUFBJTkcpCiAvKiB0aGUga2VybmVsIHByb2Nl c3MgInZtX2RhZW1vbiIqLwogc3RhdGljIHZvaWQgdm1fZGFlbW9uKHZvaWQpOwpAQCAtNjYzLDYg KzY3Myw3IEBACiAJCSAqIG1heSBhY3F1aXJlIGxvY2tzIGFuZC9vciBzbGVlcCwgc28gdGhleSBj YW4gb25seSBiZSBpbnZva2VkCiAJCSAqIHdoZW4gInRyaWVzIiBpcyBncmVhdGVyIHRoYW4gemVy by4KIAkJICovCisJCVNEVF9QUk9CRTAodm0sICwgLCB2bV9fbG93bWVtX2NhY2hlKTsKIAkJRVZF TlRIQU5ETEVSX0lOVk9LRSh2bV9sb3dtZW0sIDApOwogCiAJCS8qCkBAIC05MDQsNyArOTE1LDcg QEAKICAqCXBhc3MgMSAtIE1vdmUgaW5hY3RpdmUgdG8gY2FjaGUgb3IgZnJlZQogICoJcGFzcyAy IC0gTGF1bmRlciBkaXJ0eSBwYWdlcwogICovCi1zdGF0aWMgdm9pZAorc3RhdGljIHZvaWQgX191 c2VkCiB2bV9wYWdlb3V0X3NjYW4oc3RydWN0IHZtX2RvbWFpbiAqdm1kLCBpbnQgcGFzcykKIHsK IAl2bV9wYWdlX3QgbSwgbmV4dDsKQEAgLTkyNSw2ICs5MzYsNyBAQAogCQkvKgogCQkgKiBEZWNy ZWFzZSByZWdpc3RlcmVkIGNhY2hlIHNpemVzLgogCQkgKi8KKwkJU0RUX1BST0JFMCh2bSwgLCAs IHZtX19sb3dtZW1fc2Nhbik7CiAJCUVWRU5USEFORExFUl9JTlZPS0Uodm1fbG93bWVtLCAwKTsK IAkJLyoKIAkJICogV2UgZG8gdGhpcyBleHBsaWNpdGx5IGFmdGVyIHRoZSBjYWNoZXMgaGF2ZSBi ZWVuCkBAIC0xNjUwLDE1ICsxNjYyLDExIEBACiB9CiAKIC8qCi0gKgl2bV9wYWdlb3V0IGlzIHRo ZSBoaWdoIGxldmVsIHBhZ2VvdXQgZGFlbW9uLgorICoJdm1fcGFnZW91dF9pbml0IGluaXRpYWxp c2VzIGJhc2ljIHBhZ2VvdXQgZGFlbW9uIHNldHRpbmdzLgogICovCiBzdGF0aWMgdm9pZAotdm1f cGFnZW91dCh2b2lkKQordm1fcGFnZW91dF9pbml0KHZvaWQpCiB7Ci0jaWYgTUFYTUVNRE9NID4g MQotCWludCBlcnJvciwgaTsKLSNlbmRpZgotCiAJLyoKIAkgKiBJbml0aWFsaXplIHNvbWUgcGFn aW5nIHBhcmFtZXRlcnMuCiAJICovCkBAIC0xNzA0LDcgKzE3MTIsMTggQEAKIAkvKiBYWFggZG9l cyBub3QgcmVhbGx5IGJlbG9uZyBoZXJlICovCiAJaWYgKHZtX3BhZ2VfbWF4X3dpcmVkID09IDAp CiAJCXZtX3BhZ2VfbWF4X3dpcmVkID0gY250LnZfZnJlZV9jb3VudCAvIDM7Cit9CiAKKy8qCisg KiAgICAgdm1fcGFnZW91dCBpcyB0aGUgaGlnaCBsZXZlbCBwYWdlb3V0IGRhZW1vbi4KKyAqLwor c3RhdGljIHZvaWQKK3ZtX3BhZ2VvdXQodm9pZCkKK3sKKyNpZiBNQVhNRU1ET00gPiAxCisJaW50 IGVycm9yLCBpOworI2VuZGlmCisKIAlzd2FwX3BhZ2VyX3N3YXBfaW5pdCgpOwogI2lmIE1BWE1F TURPTSA+IDEKIAlmb3IgKGkgPSAxOyBpIDwgdm1fbmRvbWFpbnM7IGkrKykgewo= 147607 2014-09-23 17:49:01 +0000 2014-09-23 17:49:01 +0000 Current working patch against 10-Stable-BETA2 patch-10-BETA2-20140923-1 text/plain 20252 karl SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MTk4MSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMTMzLDEzICsx MzMsNiBAQCBrbWVtX3NpemUodm9pZCkKIAlyZXR1cm4gKGttZW1fc2l6ZV92YWwpOwogfQogCi11 aW50NjRfdAota21lbV91c2VkKHZvaWQpCi17Ci0KLQlyZXR1cm4gKHZtZW1fc2l6ZShrbWVtX2Fy ZW5hLCBWTUVNX0FMTE9DKSk7Ci19Ci0KIHN0YXRpYyBpbnQKIGttZW1fc3RkX2NvbnN0cnVjdG9y KHZvaWQgKm1lbSwgaW50IHNpemUgX191bnVzZWQsIHZvaWQgKnByaXZhdGUsIGludCBmbGFncykK IHsKSW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMva21lbS5oCShyZXZpc2lvbiAy NzE5ODEpCisrKyBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMvc3lzL2ttZW0uaAkod29ya2lu ZyBjb3B5KQpAQCAtNjYsNyArNjYsNiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZv aWQgKnpmc19rbWVtX2FsbG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19r bWVtX2ZyZWUodm9pZCAqYnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9p ZCk7Ci11aW50NjRfdCBrbWVtX3VzZWQodm9pZCk7CiBrbWVtX2NhY2hlX3QgKmttZW1fY2FjaGVf Y3JlYXRlKGNoYXIgKm5hbWUsIHNpemVfdCBidWZzaXplLCBzaXplX3QgYWxpZ24sCiAgICAgaW50 ICgqY29uc3RydWN0b3IpKHZvaWQgKiwgdm9pZCAqLCBpbnQpLCB2b2lkICgqZGVzdHJ1Y3Rvciko dm9pZCAqLCB2b2lkICopLAogICAgIHZvaWQgKCpyZWNsYWltKSh2b2lkICopIF9fdW51c2VkLCB2 b2lkICpwcml2YXRlLCB2bWVtX3QgKnZtcCwgaW50IGNmbGFncyk7CkBAIC03OCw2ICs3Nyw5IEBA IHZvaWQga21lbV9yZWFwKHZvaWQpOwogaW50IGttZW1fZGVidWdnaW5nKHZvaWQpOwogdm9pZCAq Y2FsbG9jKHNpemVfdCBuLCBzaXplX3Qgcyk7CiAKKyNkZWZpbmUJZnJlZW1lbQkJCQkoY250LnZf ZnJlZV9jb3VudCArIGNudC52X2NhY2hlX2NvdW50KQorI2RlZmluZQltaW5mcmVlCQkJCWNudC52 X2ZyZWVfbWluCisjZGVmaW5lCWhlYXBfYXJlbmEJCQlrbWVtX2FyZW5hCiAjZGVmaW5lCWttZW1f YWxsb2Moc2l6ZSwga21mbGFncykJemZzX2ttZW1fYWxsb2MoKHNpemUpLCAoa21mbGFncykpCiAj ZGVmaW5lCWttZW1femFsbG9jKHNpemUsIGttZmxhZ3MpCXpmc19rbWVtX2FsbG9jKChzaXplKSwg KGttZmxhZ3MpIHwgTV9aRVJPKQogI2RlZmluZQlrbWVtX2ZyZWUoYnVmLCBzaXplKQkJemZzX2tt ZW1fZnJlZSgoYnVmKSwgKHNpemUpKQpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJp cy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmli L29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCShyZXZpc2lvbiAyNzE5ODEpCisr KyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3 b3JraW5nIGNvcHkpCkBAIC0xMzgsNiArMTM4LDcgQEAKICNpbmNsdWRlIDxzeXMvc2R0Lmg+CiAK ICNpbmNsdWRlIDx2bS92bV9wYWdlb3V0Lmg+CisjaW5jbHVkZSA8bWFjaGluZS92bXBhcmFtLmg+ CiAKICNpZmRlZiBpbGx1bW9zCiAjaWZuZGVmIF9LRVJORUwKQEAgLTE4OCwxNCArMTg5LDE4IEBA IGludCBhcmNfbG90c2ZyZWVfcGVyY2VudCA9IDEwOwogc3RhdGljIGludCBhcmNfZGVhZDsKIGV4 dGVybiBpbnQgemZzX3ByZWZldGNoX2Rpc2FibGU7CiAKKy8qIAorICogS0QgMjAxNC0wOS0yMgor ICogV2UgaGF2ZSB0byBiZSBhYmxlIHRvIHRlc3QgZm9yIFVJTyB1c2UgaW5zaWRlIHRoZSBhcmMg YWxsb2NhdG9yLgorICogTk9URTogRE8gTk9UIE1PRElGWSBIRVJFIQorICovCitleHRlcm4gaW50 IHppb191c2VfdW1hOworCiAvKgogICogVGhlIGFyYyBoYXMgZmlsbGVkIGF2YWlsYWJsZSBtZW1v cnkgYW5kIGhhcyBub3cgd2FybWVkIHVwLgogICovCiBzdGF0aWMgYm9vbGVhbl90IGFyY193YXJt OwogCi0vKgotICogVGhlc2UgdHVuYWJsZXMgYXJlIGZvciBwZXJmb3JtYW5jZSBhbmFseXNpcy4K LSAqLwogdWludDY0X3QgemZzX2FyY19tYXg7CiB1aW50NjRfdCB6ZnNfYXJjX21pbjsKIHVpbnQ2 NF90IHpmc19hcmNfbWV0YV9saW1pdCA9IDA7CkBAIC0yMDQsNyArMjA5LDIwIEBAIGludCB6ZnNf YXJjX3Nocmlua19zaGlmdCA9IDA7CiBpbnQgemZzX2FyY19wX21pbl9zaGlmdCA9IDA7CiBpbnQg emZzX2Rpc2FibGVfZHVwX2V2aWN0aW9uID0gMDsKIHVpbnQ2NF90IHpmc19hcmNfYXZlcmFnZV9i bG9ja3NpemUgPSA4ICogMTAyNDsgLyogOEtCICovCit1X2ludCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0 ID0gKDEgPDwgMTYpOyAvKiBkZWZhdWx0IGJlZm9yZSBwYWdlZGFlbW9uIGluaXQgb25seSAqLwor aW50IHpmc19hcmNfcmVjbGFpbV9jYWNoZV9mcmVlID0gMTsKIAorc3RhdGljIGludCBzeXNjdGxf dmZzX3pmc19hcmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CisKKyNpZmRlZiBf S0VSTkVMCitzdGF0aWMgdm9pZAorYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9pZCAqdW51c2VkIF9f dW51c2VkKQoreworCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2bV9wYWdlb3V0X3dha2V1cF90aHJl c2ggKyAoKGNudC52X2ZyZWVfdGFyZ2V0IC0gdm1fcGFnZW91dF93YWtldXBfdGhyZXNoKSAvIDIp OworfQorU1lTSU5JVChhcmNfZnJlZV90YXJnZXRfaW5pdCwgU0lfU1VCX0tUSFJFQURfUEFHRSwg U0lfT1JERVJfQU5ZLAorICAgIGFyY19mcmVlX3RhcmdldF9pbml0LCBOVUxMKTsKKwogVFVOQUJM RV9RVUFEKCJ2ZnMuemZzLmFyY19tYXgiLCAmemZzX2FyY19tYXgpOwogVFVOQUJMRV9RVUFEKCJ2 ZnMuemZzLmFyY19taW4iLCAmemZzX2FyY19taW4pOwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFy Y19tZXRhX2xpbWl0IiwgJnpmc19hcmNfbWV0YV9saW1pdCk7CkBAIC0yMTcsNyArMjM1LDQwIEBA IFNZU0NUTF9VUVVBRChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19taW4sIENUTEZMQUdfCiBTWVND VExfVVFVQUQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfYXZlcmFnZV9ibG9ja3NpemUsIENUTEZM QUdfUkRUVU4sCiAgICAgJnpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUsIDAsCiAgICAgIkFSQyBh dmVyYWdlIGJsb2Nrc2l6ZSIpOworU1lTQ1RMX0lOVChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19y ZWNsYWltX2NhY2hlX2ZyZWUsIENUTEZMQUdfUldUVU4sCisgICAgJnpmc19hcmNfcmVjbGFpbV9j YWNoZV9mcmVlLCAwLAorICAgICJBUkMgdHJlYXRzIGNhY2hlZCBwYWdlcyBhcyBmcmVlIGJsb2Nr c2l6ZSIpOworLyoKKyAqIFdlIGRvbid0IGhhdmUgYSB0dW5hYmxlIGZvciBhcmNfZnJlZV90YXJn ZXQgZHVlIHRvIHRoZSBkZXBlbmRlbmN5IG9uCisgKiBwYWdlZGFlbW9uIGluaXRpYWxpc2F0aW9u LgorICovCitTWVNDVExfUFJPQyhfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19mcmVlX3RhcmdldCwK KyAgICBDVExUWVBFX1VJTlQgfCBDVExGTEFHX01QU0FGRSB8IENUTEZMQUdfUlcsIDAsIHNpemVv Zih1X2ludCksCisgICAgc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFyZ2V0LCAiSVUiLAorICAg ICJEZXNpcmVkIG51bWJlciBvZiBmcmVlIHBhZ2VzIGJlbG93IHdoaWNoIEFSQyB0cmlnZ2VycyBy ZWNsYWltIik7CiAKK3N0YXRpYyBpbnQKK3N5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldChT WVNDVExfSEFORExFUl9BUkdTKQoreworCXVfaW50IHZhbDsKKwlpbnQgZXJyOworCisJdmFsID0g emZzX2FyY19mcmVlX3RhcmdldDsKKwllcnIgPSBzeXNjdGxfaGFuZGxlX2ludChvaWRwLCAmdmFs LCAwLCByZXEpOworCWlmIChlcnIgIT0gMCB8fCByZXEtPm5ld3B0ciA9PSBOVUxMKQorCQlyZXR1 cm4gKGVycik7CisKKwlpZiAodmFsIDwgbWluZnJlZSkKKwkJcmV0dXJuIChFSU5WQUwpOworCWlm ICh2YWwgPiBjbnQudl9wYWdlX2NvdW50KQorCQlyZXR1cm4gKEVJTlZBTCk7CisKKwl6ZnNfYXJj X2ZyZWVfdGFyZ2V0ID0gdmFsOworCisJcmV0dXJuICgwKTsKK30KKyNlbmRpZgorCiAvKgogICog Tm90ZSB0aGF0IGJ1ZmZlcnMgY2FuIGJlIGluIG9uZSBvZiA2IHN0YXRlczoKICAqCUFSQ19hbm9u CS0gYW5vbnltb3VzIChkaXNjdXNzZWQgYmVsb3cpCkBAIC0yNDIxLDYgKzI0NzIsNyBAQCBhcmNf Zmx1c2goc3BhX3QgKnNwYSkKIHZvaWQKIGFyY19zaHJpbmsodm9pZCkKIHsKKwogCWlmIChhcmNf YyA+IGFyY19jX21pbikgewogCQl1aW50NjRfdCB0b19mcmVlOwogCkBAIC0yNDI5LDYgKzI0ODEs OSBAQCBhcmNfc2hyaW5rKHZvaWQpCiAjZWxzZQogCQl0b19mcmVlID0gYXJjX2MgPj4gYXJjX3No cmlua19zaGlmdDsKICNlbmRpZgorCQlEVFJBQ0VfUFJPQkU0KGFyY19fc2hyaW5rLCB1aW50NjRf dCwgYXJjX2MsIHVpbnQ2NF90LAorCQkJYXJjX2NfbWluLCB1aW50NjRfdCwgYXJjX3AsIHVpbnQ2 NF90LCB0b19mcmVlKTsKKwogCQlpZiAoYXJjX2MgPiBhcmNfY19taW4gKyB0b19mcmVlKQogCQkJ YXRvbWljX2FkZF82NCgmYXJjX2MsIC10b19mcmVlKTsKIAkJZWxzZQpAQCAtMjQzOSwxMiArMjQ5 NCwxOSBAQCBhcmNfc2hyaW5rKHZvaWQpCiAJCQlhcmNfYyA9IE1BWChhcmNfc2l6ZSwgYXJjX2Nf bWluKTsKIAkJaWYgKGFyY19wID4gYXJjX2MpCiAJCQlhcmNfcCA9IChhcmNfYyA+PiAxKTsKKwor CQlEVFJBQ0VfUFJPQkUyKGFyY19fc2hydW5rLCB1aW50NjRfdCwgYXJjX2MsIHVpbnQ2NF90LAor CQkJYXJjX3ApOworCiAJCUFTU0VSVChhcmNfYyA+PSBhcmNfY19taW4pOwogCQlBU1NFUlQoKGlu dDY0X3QpYXJjX3AgPj0gMCk7CiAJfQogCi0JaWYgKGFyY19zaXplID4gYXJjX2MpCisJaWYgKGFy Y19zaXplID4gYXJjX2MpIHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3Nocmlua19hZGp1c3QsIHVp bnQ2NF90LCBhcmNfc2l6ZSwKKwkJCXVpbnQ2NF90LCBhcmNfYyk7CiAJCWFyY19hZGp1c3QoKTsK Kwl9CiB9CiAKIHN0YXRpYyBpbnQgbmVlZGZyZWUgPSAwOwpAQCAtMjQ1MiwxOCArMjUxNCwzNSBA QCBzdGF0aWMgaW50IG5lZWRmcmVlID0gMDsKIHN0YXRpYyBpbnQKIGFyY19yZWNsYWltX25lZWRl ZCh2b2lkKQogeworCXVfaW50IGZtOwogCiAjaWZkZWYgX0tFUk5FTAorCWlmIChhcmNfc2l6ZSA8 PSBhcmNfY19taW4pIHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fbWluLCB1aW50NjRf dCwgYXJjX3NpemUsCisJCSAgICB1aW50NjRfdCwgYXJjX2NfbWluKTsKKwkJcmV0dXJuICgwKTsK Kwl9CiAKLQlpZiAobmVlZGZyZWUpCisJaWYgKG5lZWRmcmVlKSB7CisJCURUUkFDRV9QUk9CRShh cmNfX3JlY2xhaW1fbmVlZGZyZWUpOwogCQlyZXR1cm4gKDEpOworCX0KIAogCS8qCiAJICogQ29v cGVyYXRlIHdpdGggcGFnZWRhZW1vbiB3aGVuIGl0J3MgdGltZSBmb3IgaXQgdG8gc2NhbgogCSAq IGFuZCByZWNsYWltIHNvbWUgcGFnZXMuCiAJICovCi0JaWYgKHZtX3BhZ2luZ19uZWVkZWQoKSkK KwlpZiAoemZzX2FyY19yZWNsYWltX2NhY2hlX2ZyZWUgPT0gMCkKKwkJZm0gPSBjbnQudl9mcmVl X2NvdW50OworCWVsc2UKKwkJZm0gPSBmcmVlbWVtOworCisJaWYgKGZtIDwgemZzX2FyY19mcmVl X3RhcmdldCkgeworCQlEVFJBQ0VfUFJPQkUzKGFyY19fcmVjbGFpbV9mcmVlbWVtLCB1aW50NjRf dCwKKwkJICAgIGZtLCB1aW50NjRfdCwgemZzX2FyY19mcmVlX3RhcmdldCwKKwkJICAgIGludCwg emZzX2FyY19yZWNsYWltX2NhY2hlX2ZyZWUpOwogCQlyZXR1cm4gKDEpOworCX0KIAogI2lmZGVm IHN1bgogCS8qCkBAIC0yNDkxLDggKzI1NzAsMTkgQEAgYXJjX3JlY2xhaW1fbmVlZGVkKHZvaWQp CiAJaWYgKGF2YWlscm1lbSA8IHN3YXBmc19taW5mcmVlICsgc3dhcGZzX3Jlc2VydmUgKyBleHRy YSkKIAkJcmV0dXJuICgxKTsKIAotI2lmIGRlZmluZWQoX19pMzg2KQogCS8qCisJICogQ2hlY2sg dGhhdCB3ZSBoYXZlIGVub3VnaCBhdmFpbHJtZW0gdGhhdCBtZW1vcnkgbG9ja2luZyAoZS5nLiwg dmlhCisJICogbWxvY2soM0MpIG9yIG1lbWNudGwoMikpIGNhbiBzdGlsbCBzdWNjZWVkLiAgKHBh Z2VzX3BwX21heGltdW0KKwkgKiBzdG9yZXMgdGhlIG51bWJlciBvZiBwYWdlcyB0aGF0IGNhbm5v dCBiZSBsb2NrZWQ7IHdoZW4gYXZhaWxybWVtCisJICogZHJvcHMgYmVsb3cgcGFnZXNfcHBfbWF4 aW11bSwgcGFnZSBsb2NraW5nIG1lY2hhbmlzbXMgc3VjaCBhcworCSAqIHBhZ2VfcHBfbG9jaygp IHdpbGwgZmFpbC4pCisJICovCisJaWYgKGF2YWlscm1lbSA8PSBwYWdlc19wcF9tYXhpbXVtKQor CQlyZXR1cm4gKDEpOworCisjZW5kaWYJLyogc3VuICovCisjaWYgZGVmaW5lZChfX2kzODYpIHx8 ICFkZWZpbmVkKFVNQV9NRF9TTUFMTF9BTExPQykKKwkvKgogCSAqIElmIHdlJ3JlIG9uIGFuIGkz ODYgcGxhdGZvcm0sIGl0J3MgcG9zc2libGUgdGhhdCB3ZSdsbCBleGhhdXN0IHRoZQogCSAqIGtl cm5lbCBoZWFwIHNwYWNlIGJlZm9yZSB3ZSBldmVyIHJ1biBvdXQgb2YgYXZhaWxhYmxlIHBoeXNp Y2FsCiAJICogbWVtb3J5LiAgTW9zdCBjaGVja3Mgb2YgdGhlIHNpemUgb2YgdGhlIGhlYXBfYXJl YSBjb21wYXJlIGFnYWluc3QKQEAgLTI1MDMsMzIgKzI1OTMsNjcgQEAgYXJjX3JlY2xhaW1fbmVl ZGVkKHZvaWQpCiAJICogaGVhcCBpcyBhbGxvY2F0ZWQuICAoT3IsIGluIHRoZSBjYWxjdWxhdGlv biwgaWYgbGVzcyB0aGFuIDEvNHRoIGlzCiAJICogZnJlZSkKIAkgKi8KLQlpZiAoYnRvcCh2bWVt X3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSkgPAotCSAgICAoYnRvcCh2bWVtX3NpemUoaGVh cF9hcmVuYSwgVk1FTV9GUkVFIHwgVk1FTV9BTExPQykpID4+IDIpKQorCWlmICh2bWVtX3NpemUo aGVhcF9hcmVuYSwgVk1FTV9GUkVFKSA8CisJICAgICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1F TV9GUkVFIHwgVk1FTV9BTExPQykgPj4gMikpIHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xh aW1fdXNlZCwgdWludDY0X3QsCisJCSAgICB2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVF KSwgdWludDY0X3QsCisJCSAgICAodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZN RU1fQUxMT0MpKSA+PiAyKTsKIAkJcmV0dXJuICgxKTsKKwl9CiAjZW5kaWYKLSNlbHNlCS8qICFz dW4gKi8KLQlpZiAoa21lbV91c2VkKCkgPiAoa21lbV9zaXplKCkgKiAzKSAvIDQpCisjaWZkZWYg c3VuCisJLyoKKwkgKiBJZiB6aW8gZGF0YSBwYWdlcyBhcmUgYmVpbmcgYWxsb2NhdGVkIG91dCBv ZiBhIHNlcGFyYXRlIGhlYXAgc2VnbWVudCwKKwkgKiB0aGVuIGVuZm9yY2UgdGhhdCB0aGUgc2l6 ZSBvZiBhdmFpbGFibGUgdm1lbSBmb3IgdGhpcyBhcmVuYSByZW1haW5zCisJICogYWJvdmUgYWJv dXQgMS8xNnRoIGZyZWUuCisJICoKKwkgKiBOb3RlOiBUaGUgMS8xNnRoIGFyZW5hIGZyZWUgcmVx dWlyZW1lbnQgd2FzIHB1dCBpbiBwbGFjZQorCSAqIHRvIGFnZ3Jlc3NpdmVseSBldmljdCBtZW1v cnkgZnJvbSB0aGUgYXJjIGluIG9yZGVyIHRvIGF2b2lkCisJICogbWVtb3J5IGZyYWdtZW50YXRp b24gaXNzdWVzLgorCSAqLworCWlmICh6aW9fYXJlbmEgIT0gTlVMTCAmJgorCSAgICB2bWVtX3Np emUoemlvX2FyZW5hLCBWTUVNX0ZSRUUpIDwKKwkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZN RU1fQUxMT0MpID4+IDQpKQogCQlyZXR1cm4gKDEpOwogI2VuZGlmCS8qIHN1biAqLwotCi0jZWxz ZQorI2Vsc2UJLyogX0tFUk5FTCAqLwogCWlmIChzcGFfZ2V0X3JhbmRvbSgxMDApID09IDApCiAJ CXJldHVybiAoMSk7Ci0jZW5kaWYKKyNlbmRpZgkvKiBfS0VSTkVMICovCisJRFRSQUNFX1BST0JF KGFyY19fcmVjbGFpbV9ubyk7CisKIAlyZXR1cm4gKDApOwogfQogCiBleHRlcm4ga21lbV9jYWNo ZV90CSp6aW9fYnVmX2NhY2hlW107CiBleHRlcm4ga21lbV9jYWNoZV90CSp6aW9fZGF0YV9idWZf Y2FjaGVbXTsKIAotc3RhdGljIHZvaWQKLWFyY19rbWVtX3JlYXBfbm93KGFyY19yZWNsYWltX3N0 cmF0ZWd5X3Qgc3RyYXQpCitzdGF0aWMgdm9pZCBfX3VzZWQKK3JlYXBfYXJjX2NhY2hlcygpCiB7 Ci0Jc2l6ZV90CQkJaTsKKwlzaXplX3QJCWk7CiAJa21lbV9jYWNoZV90CQkqcHJldl9jYWNoZSA9 IE5VTEw7CiAJa21lbV9jYWNoZV90CQkqcHJldl9kYXRhX2NhY2hlID0gTlVMTDsKIAorCWZvciAo aSA9IDA7IGkgPCBTUEFfTUFYQkxPQ0tTSVpFID4+IFNQQV9NSU5CTE9DS1NISUZUOyBpKyspIHsK KwkJaWYgKHppb19idWZfY2FjaGVbaV0gIT0gcHJldl9jYWNoZSkgeworCQkJcHJldl9jYWNoZSA9 IHppb19idWZfY2FjaGVbaV07CisJCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19idWZfY2FjaGVb aV0pOworCQl9CisJCWlmICh6aW9fZGF0YV9idWZfY2FjaGVbaV0gIT0gcHJldl9kYXRhX2NhY2hl KSB7CisJCQlwcmV2X2RhdGFfY2FjaGUgPSB6aW9fZGF0YV9idWZfY2FjaGVbaV07CisJCQlrbWVt X2NhY2hlX3JlYXBfbm93KHppb19kYXRhX2J1Zl9jYWNoZVtpXSk7CisJCX0KKwl9CisJa21lbV9j YWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOworCWttZW1fY2FjaGVfcmVhcF9ub3coaGRyX2NhY2hl KTsKK30KKworc3RhdGljIHZvaWQgX191c2VkCithcmNfa21lbV9yZWFwX25vdyhhcmNfcmVjbGFp bV9zdHJhdGVneV90IHN0cmF0KQoreworCisJRFRSQUNFX1BST0JFKGFyY19fa21lbV9yZWFwX3N0 YXJ0KTsKICNpZmRlZiBfS0VSTkVMCiAJaWYgKGFyY19tZXRhX3VzZWQgPj0gYXJjX21ldGFfbGlt aXQpIHsKIAkJLyoKQEAgLTI1NTIsMTggKzI2NzcsMTcgQEAgZXh0ZXJuIGttZW1fY2FjaGVfdAkq emlvX2RhdGFfYnVmX2NhY2hlW107CiAJaWYgKHN0cmF0ID09IEFSQ19SRUNMQUlNX0FHR1IpCiAJ CWFyY19zaHJpbmsoKTsKIAotCWZvciAoaSA9IDA7IGkgPCBTUEFfTUFYQkxPQ0tTSVpFID4+IFNQ QV9NSU5CTE9DS1NISUZUOyBpKyspIHsKLQkJaWYgKHppb19idWZfY2FjaGVbaV0gIT0gcHJldl9j YWNoZSkgewotCQkJcHJldl9jYWNoZSA9IHppb19idWZfY2FjaGVbaV07Ci0JCQlrbWVtX2NhY2hl X3JlYXBfbm93KHppb19idWZfY2FjaGVbaV0pOwotCQl9Ci0JCWlmICh6aW9fZGF0YV9idWZfY2Fj aGVbaV0gIT0gcHJldl9kYXRhX2NhY2hlKSB7Ci0JCQlwcmV2X2RhdGFfY2FjaGUgPSB6aW9fZGF0 YV9idWZfY2FjaGVbaV07Ci0JCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19kYXRhX2J1Zl9jYWNo ZVtpXSk7Ci0JCX0KLQl9Ci0Ja21lbV9jYWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOwotCWttZW1f Y2FjaGVfcmVhcF9ub3coaGRyX2NhY2hlKTsKKwlyZWFwX2FyY19jYWNoZXMoKTsKKworI2lmZGVm IHN1bgorCS8qCisJICogQXNrIHRoZSB2bWVtIGFyZWFuYSB0byByZWNsYWltIHVudXNlZCBtZW1v cnkgZnJvbSBpdHMKKwkgKiBxdWFudHVtIGNhY2hlcy4KKwkgKi8KKwlpZiAoemlvX2FyZW5hICE9 IE5VTEwgJiYgc3RyYXQgPT0gQVJDX1JFQ0xBSU1fQUdHUikKKwkJdm1lbV9xY2FjaGVfcmVhcCh6 aW9fYXJlbmEpOworI2VuZGlmCisJRFRSQUNFX1BST0JFKGFyY19fa21lbV9yZWFwX2VuZCk7CiB9 CiAKIHN0YXRpYyB2b2lkCkBAIC0yNTcyLDE1ICsyNjk2LDM1IEBAIGFyY19yZWNsYWltX3RocmVh ZCh2b2lkICpkdW1teSBfX3VudXNlZCkKIAljbG9ja190CQkJZ3Jvd3RpbWUgPSAwOwogCWFyY19y ZWNsYWltX3N0cmF0ZWd5X3QJbGFzdF9yZWNsYWltID0gQVJDX1JFQ0xBSU1fQ09OUzsKIAljYWxs Yl9jcHJfdAkJY3ByOworCWludAkJCWF1dG9yZWFwID0gMDsKIAogCUNBTExCX0NQUl9JTklUKCZj cHIsICZhcmNfcmVjbGFpbV90aHJfbG9jaywgY2FsbGJfZ2VuZXJpY19jcHIsIEZUQUcpOwogCiAJ bXV0ZXhfZW50ZXIoJmFyY19yZWNsYWltX3Rocl9sb2NrKTsKKwogCXdoaWxlIChhcmNfdGhyZWFk X2V4aXQgPT0gMCkgeworCisjaWZkZWYJX0tFUk5FTAorLyogS0QgMjAxNC0wOS0yMgorICogUHJv dGVjdCBhZ2FpbnN0IFVNQSBmcmVlIG1lbW9yeSBibG9hdC4gIFdlIGFscmVhZHkgZG8gdGhpcyBv biBhIGxvdy1tZW1vcnkKKyAqIGJhc2lzIGluIHRoZSBhbGxvY2F0b3I7IGl0IGhhcyB0byBoYXBw ZW4gdGhlcmUgcmF0aGVyIHRoYW4gaGVyZSBkdWUgdG8gCisgKiByZXNwb25zZSB0aW1lIGNvbnNp ZGVyYXRpb25zLiAgTWFrZSB0aGUgY2FsbCBoZXJlIG9uY2UgZXZlcnkgMTAgcGFzc2VzIGFzIAor ICogd2VsbDsgdGhpcyByZWNsYWltcyB1bnVzZWQgVU1BIGJ1ZmZlcnMgZXZlcnkgMTAgc2Vjb25k cyBvbiBhbiBpZGxlIHN5c3RlbSAKKyAqIGFuZCBtb3JlIGZyZXF1ZW50bHkgaWYgdGhlIHJlY2xh aW0gdGhyZWFkIGdldHMgd29rZW4gdXAgYnkgbG93IFJBTSAKKyAqIGNvbmRpdGlvbnMuCisgKi8K KwkJaWYgKCh6aW9fdXNlX3VtYSkgJiYgKGF1dG9yZWFwKysgPT0gMTApKSB7CisJCQlhdXRvcmVh cCA9IDA7CisJCQlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX3RpbWVkX3JlYXApOworCQkJcmVh cF9hcmNfY2FjaGVzKCk7CisJCX0KKyNlbmRpZgkvKiBfS0VSTkVMICovCisKIAkJaWYgKGFyY19y ZWNsYWltX25lZWRlZCgpKSB7CiAKIAkJCWlmIChhcmNfbm9fZ3JvdykgewogCQkJCWlmIChsYXN0 X3JlY2xhaW0gPT0gQVJDX1JFQ0xBSU1fQ09OUykgeworCQkJCQlEVFJBQ0VfUFJPQkUoYXJjX19y ZWNsYWltX2FnZ3Jfbm9fZ3Jvdyk7CiAJCQkJCWxhc3RfcmVjbGFpbSA9IEFSQ19SRUNMQUlNX0FH R1I7CiAJCQkJfSBlbHNlIHsKIAkJCQkJbGFzdF9yZWNsYWltID0gQVJDX1JFQ0xBSU1fQ09OUzsK QEAgLTI1ODgsNiArMjczMiw3IEBAIGFyY19yZWNsYWltX3RocmVhZCh2b2lkICpkdW1teSBfX3Vu dXNlZCkKIAkJCX0gZWxzZSB7CiAJCQkJYXJjX25vX2dyb3cgPSBUUlVFOwogCQkJCWxhc3RfcmVj bGFpbSA9IEFSQ19SRUNMQUlNX0FHR1I7CisJCQkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9h Z2dyKTsKIAkJCQltZW1iYXJfcHJvZHVjZXIoKTsKIAkJCX0KIApAQCAtMjYwMiw2ICsyNzQ3LDcg QEAgYXJjX3JlY2xhaW1fdGhyZWFkKHZvaWQgKmR1bW15IF9fdW51c2VkKQogCQkJCSAqLwogCQkJ CWFyY19ub19ncm93ID0gVFJVRTsKIAkJCQlsYXN0X3JlY2xhaW0gPSBBUkNfUkVDTEFJTV9BR0dS OworCQkJCURUUkFDRV9QUk9CRShhcmNfX3JlY2xhaW1fYWdncl9uZWVkZnJlZSk7CiAJCQl9CiAJ CQlhcmNfa21lbV9yZWFwX25vdyhsYXN0X3JlY2xhaW0pOwogCQkJYXJjX3dhcm0gPSBCX1RSVUU7 CkBAIC0yNjE4LDYgKzI3NjQsNyBAQCBhcmNfcmVjbGFpbV90aHJlYWQodm9pZCAqZHVtbXkgX191 bnVzZWQpCiAjaWZkZWYgX0tFUk5FTAogCQlpZiAobmVlZGZyZWUpIHsKIAkJCW5lZWRmcmVlID0g MDsKKwkJCURUUkFDRV9QUk9CRShhcmNfX2NsZWFyX25lZWRmcmVlKTsKIAkJCXdha2V1cCgmbmVl ZGZyZWUpOwogCQl9CiAjZW5kaWYKQEAgLTI2OTIsNiArMjgzOSw3IEBAIGFyY19hZGFwdChpbnQg Ynl0ZXMsIGFyY19zdGF0ZV90ICpzdGF0ZSkKIAkgKiBjYWNoZSBzaXplLCBpbmNyZW1lbnQgdGhl IHRhcmdldCBjYWNoZSBzaXplCiAJICovCiAJaWYgKGFyY19zaXplID4gYXJjX2MgLSAoMlVMTCA8 PCBTUEFfTUFYQkxPQ0tTSElGVCkpIHsKKwkJRFRSQUNFX1BST0JFMShhcmNfX2luY19hZGFwdCwg aW50LCBieXRlcyk7CiAJCWF0b21pY19hZGRfNjQoJmFyY19jLCAoaW50NjRfdClieXRlcyk7CiAJ CWlmIChhcmNfYyA+IGFyY19jX21heCkKIAkJCWFyY19jID0gYXJjX2NfbWF4OwpAQCAtMjcxMywy MCArMjg2MSw2IEBAIGFyY19ldmljdF9uZWVkZWQoYXJjX2J1Zl9jb250ZW50c190IHR5cGUpCiAJ aWYgKHR5cGUgPT0gQVJDX0JVRkNfTUVUQURBVEEgJiYgYXJjX21ldGFfdXNlZCA+PSBhcmNfbWV0 YV9saW1pdCkKIAkJcmV0dXJuICgxKTsKIAotI2lmZGVmIHN1bgotI2lmZGVmIF9LRVJORUwKLQkv KgotCSAqIElmIHppbyBkYXRhIHBhZ2VzIGFyZSBiZWluZyBhbGxvY2F0ZWQgb3V0IG9mIGEgc2Vw YXJhdGUgaGVhcCBzZWdtZW50LAotCSAqIHRoZW4gZW5mb3JjZSB0aGF0IHRoZSBzaXplIG9mIGF2 YWlsYWJsZSB2bWVtIGZvciB0aGlzIGFyZWEgcmVtYWlucwotCSAqIGFib3ZlIGFib3V0IDEvMzJu ZCBmcmVlLgotCSAqLwotCWlmICh0eXBlID09IEFSQ19CVUZDX0RBVEEgJiYgemlvX2FyZW5hICE9 IE5VTEwgJiYKLQkgICAgdm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9GUkVFKSA8Ci0JICAgICh2 bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0FMTE9DKSA+PiA1KSkKLQkJcmV0dXJuICgxKTsKLSNl bmRpZgotI2VuZGlmCS8qIHN1biAqLwotCiAJaWYgKGFyY19yZWNsYWltX25lZWRlZCgpKQogCQly ZXR1cm4gKDEpOwogCkBAIC0yODA3LDYgKzI5NDEsMTkgQEAgYXJjX2dldF9kYXRhX2J1ZihhcmNf YnVmX3QgKmJ1ZikKIAkJCWFyY19zcGFjZV9jb25zdW1lKHNpemUsIEFSQ19TUEFDRV9EQVRBKTsK IAkJfSBlbHNlIHsKIAkJCUFTU0VSVCh0eXBlID09IEFSQ19CVUZDX0RBVEEpOworI2lmZGVmCV9L RVJORUwKKy8qIEtEIDIwMTQtMDktMjIKKyAqIEl0IHdvdWxkIGJlIG5pY2UgaWYgd2UgY291bGQg bGVhdmUgdGhpcyB0byB0aGUgYXJjX3JlY2xhaW0gdGhyZWFkLgorICogVW5mb3J0dW5hdGVseSB3 ZSBjYW5ub3Q7IHRoZSB0ZXN0IGhhcyB0byBiZSBkb25lIGhlcmUgYXMgd2VsbCwgYmVjYXVzZQor ICogdW5kZXIgaGVhdnkgSS9PIGRlbWFuZCB3ZSBjYW4gZ3JhYiBlbm91Z2ggUkFNIGZhc3QgZW5v dWdoIHRvIGluZHVjZQorICogbmFzdHkgb3NjaWxsYXRpb24gcHJvYmxlbXMuICBGb3J0dW5hdGVs eSB3ZSBvbmx5IG5lZWQgdG8gY2FsbCB0aGlzIHdoZW4KKyAqIHRoZSBzeXN0ZW0gaXMgdW5kZXIg cmVhc29uYWJseS1zZXZlcmUgbWVtb3J5IHN0cmVzcy4KKyAqLworCQkJaWYgKHppb191c2VfdW1h ICYmIChwdG9iKGNudC52X2ZyZWVfY291bnQpICsgc2l6ZSA8IHB0b2IoY250LnZfZnJlZV90YXJn ZXQpKSkgeworCQkJCURUUkFDRV9QUk9CRTMoYXJjX19hbGxvY19sb3dtZW1fcmVhcCwgaW50LCBj bnQudl9mcmVlX2NvdW50LCBpbnQsIHNpemUsIGludCwgY250LnZfZnJlZV90YXJnZXQpOyAKKwkJ CQlyZWFwX2FyY19jYWNoZXMoKTsKKwkJCX0KKyNlbmRpZgkvKiBfS0VSTkVMICovCiAJCQlidWYt PmJfZGF0YSA9IHppb19kYXRhX2J1Zl9hbGxvYyhzaXplKTsKIAkJCUFSQ1NUQVRfSU5DUihhcmNz dGF0X2RhdGFfc2l6ZSwgc2l6ZSk7CiAJCQlhdG9taWNfYWRkXzY0KCZhcmNfc2l6ZSwgc2l6ZSk7 CkBAIC0zODg1LDIwICs0MDMyLDE2IEBAIHN0YXRpYyBpbnQKIGFyY19tZW1vcnlfdGhyb3R0bGUo dWludDY0X3QgcmVzZXJ2ZSwgdWludDY0X3QgdHhnKQogewogI2lmZGVmIF9LRVJORUwKLQl1aW50 NjRfdCBhdmFpbGFibGVfbWVtb3J5ID0KLQkgICAgcHRvYSgodWludG1heF90KWNudC52X2ZyZWVf Y291bnQgKyBjbnQudl9jYWNoZV9jb3VudCk7CisJdWludDY0X3QgYXZhaWxhYmxlX21lbW9yeSA9 IHB0b2IoZnJlZW1lbSk7CiAJc3RhdGljIHVpbnQ2NF90IHBhZ2VfbG9hZCA9IDA7CiAJc3RhdGlj IHVpbnQ2NF90IGxhc3RfdHhnID0gMDsKIAotI2lmZGVmIHN1bgotI2lmIGRlZmluZWQoX19pMzg2 KQorI2lmIGRlZmluZWQoX19pMzg2KSB8fCAhZGVmaW5lZChVTUFfTURfU01BTExfQUxMT0MpCiAJ YXZhaWxhYmxlX21lbW9yeSA9Ci0JICAgIE1JTihhdmFpbGFibGVfbWVtb3J5LCB2bWVtX3NpemUo aGVhcF9hcmVuYSwgVk1FTV9GUkVFKSk7CisJICAgIE1JTihhdmFpbGFibGVfbWVtb3J5LCBwdG9i KHZtZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUpKSk7CiAjZW5kaWYKLSNlbmRpZgkvKiBz dW4gKi8KIAotCWlmIChjbnQudl9mcmVlX2NvdW50ICsgY250LnZfY2FjaGVfY291bnQgPgotCSAg ICAodWludDY0X3QpcGh5c21lbSAqIGFyY19sb3RzZnJlZV9wZXJjZW50IC8gMTAwKQorCWlmIChm cmVlbWVtID4gKHVpbnQ2NF90KXBoeXNtZW0gKiBhcmNfbG90c2ZyZWVfcGVyY2VudCAvIDEwMCkK IAkJcmV0dXJuICgwKTsKIAogCWlmICh0eGcgPiBsYXN0X3R4ZykgewpAQCAtMzkxMSw3ICs0MDU0 LDcgQEAgYXJjX21lbW9yeV90aHJvdHRsZSh1aW50NjRfdCByZXNlcnZlLCB1aW50NjRfdCB0eGcK IAkgKiBjb250aW51ZSB0byBsZXQgcGFnZSB3cml0ZXMgb2NjdXIgYXMgcXVpY2tseSBhcyBwb3Nz aWJsZS4KIAkgKi8KIAlpZiAoY3VycHJvYyA9PSBwYWdlcHJvYykgewotCQlpZiAocGFnZV9sb2Fk ID4gYXZhaWxhYmxlX21lbW9yeSAvIDQpCisJCWlmIChwYWdlX2xvYWQgPiBNQVgocHRvYihtaW5m cmVlKSwgYXZhaWxhYmxlX21lbW9yeSkgLyA0KQogCQkJcmV0dXJuIChTRVRfRVJST1IoRVJFU1RB UlQpKTsKIAkJLyogTm90ZTogcmVzZXJ2ZSBpcyBpbmZsYXRlZCwgc28gd2UgZGVmbGF0ZSAqLwog CQlwYWdlX2xvYWQgKz0gcmVzZXJ2ZSAvIDg7CkBAIC0zOTM5LDggKzQwODIsMTAgQEAgYXJjX3Rl bXByZXNlcnZlX3NwYWNlKHVpbnQ2NF90IHJlc2VydmUsIHVpbnQ2NF90IHQKIAlpbnQgZXJyb3I7 CiAJdWludDY0X3QgYW5vbl9zaXplOwogCi0JaWYgKHJlc2VydmUgPiBhcmNfYy80ICYmICFhcmNf bm9fZ3JvdykKKwlpZiAocmVzZXJ2ZSA+IGFyY19jLzQgJiYgIWFyY19ub19ncm93KSB7CiAJCWFy Y19jID0gTUlOKGFyY19jX21heCwgcmVzZXJ2ZSAqIDQpOworCQlEVFJBQ0VfUFJPQkUxKGFyY19f c2V0X3Jlc2VydmUsIHVpbnQ2NF90LCBhcmNfYyk7CisJfQogCWlmIChyZXNlcnZlID4gYXJjX2Mp CiAJCXJldHVybiAoU0VUX0VSUk9SKEVOT01FTSkpOwogCkBAIC0zOTk0LDYgKzQxMzksNyBAQCBh cmNfbG93bWVtKHZvaWQgKmFyZyBfX3VudXNlZCwgaW50IGhvd3RvIF9fdW51c2VkKQogCW11dGV4 X2VudGVyKCZhcmNfbG93bWVtX2xvY2spOwogCW11dGV4X2VudGVyKCZhcmNfcmVjbGFpbV90aHJf bG9jayk7CiAJbmVlZGZyZWUgPSAxOworCURUUkFDRV9QUk9CRShhcmNfX25lZWRmcmVlKTsKIAlj dl9zaWduYWwoJmFyY19yZWNsYWltX3Rocl9jdik7CiAKIAkvKgpJbmRleDogc3lzL2NkZGwvY29u dHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9kbXVfdHguYwo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90eC5j CShyZXZpc2lvbiAyNzE5ODEpCisrKyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9j b21tb24vZnMvemZzL2RtdV90eC5jCSh3b3JraW5nIGNvcHkpCkBAIC00Miw2ICs0Miw3IEBACiB0 eXBlZGVmIHZvaWQgKCpkbXVfdHhfaG9sZF9mdW5jX3QpKGRtdV90eF90ICp0eCwgc3RydWN0IGRu b2RlICpkbiwKICAgICB1aW50NjRfdCBhcmcxLCB1aW50NjRfdCBhcmcyKTsKIAorZXh0ZXJuCWlu dAl6aW9fdXNlX3VtYTsJLyogTmVlZHMgdG8gYmUgdmlzaWJsZTsgRE8gTk9UIE1PRElGWSEgKi8K IAogZG11X3R4X3QgKgogZG11X3R4X2NyZWF0ZV9kZChkc2xfZGlyX3QgKmRkKQpAQCAtMTI4MSw2 ICsxMjgyLDMwIEBAIGRtdV90eF9hc3NpZ24oZG11X3R4X3QgKnR4LCB0eGdfaG93X3QgdHhnX2hv dykKIAlpZiAodHhnX2hvdyA9PSBUWEdfV0FJVEVEKQogCQl0eC0+dHhfd2FpdGVkID0gQl9UUlVF OwogCisjaWZkZWYJX0tFUk5FTAorCS8qCisgCSAqIEtEIDIwMTQtMDktMjIKKyAJICogSWYgVU1B IGlzIGVuYWJsZWQgaXQgY2FuIG9ubHkgcmV0dXJuIGEgcHJldmlvdXNseS11c2VkIGJsb2NrCisJ ICogb2YgaWRlbnRpY2FsIHNpemUgdG8gd2hhdCBpdCBoYWQgb3V0IGJlZm9yZS4gIElmIGl0J3Mg bm90IHRoZQorCSAqIHNhbWUgc2l6ZSBpdCB3aWxsIGFsbG9jYXRlIGEgbmV3IG9uZS4gIFRoaXMg aXMgYSBwcm9ibGVtIGJlY2F1c2UKKwkgKiBkaXJ0eV9kYXRhX21heCBpcyB0aGUgdG90YWwgZGly dHkgd3JpdGUgZGF0YSBhbGxvd2VkIG91dCBhdCBhbnkgCisJICogZ2l2ZW4gdGltZSwgYnV0IHdp dGggVU1BIG9uIHRoYXQgY2FuIG11bHRpcGx5IGJ5IHRoZSBudW1iZXIgb2YgCisJICogZGlmZmVy ZW50IGJsb2NrIHNpemVzICghISkgcmVxdWVzdGVkIGluIHRlcm1zIG9mIGZyZWUgUkFNIHRoYXQg CisJICogaXMgbGVmdCBhbGxvY2F0ZWQgYnV0IHVudXNlZC4gIEZvciB0aGlzIHJlYXNvbiBuZXZl ciBhbGxvdyAKKwkgKiBkaXJ0eV9kYXRhX21heCB0byBleGNlZWQgdGhlIGRpZmZlcmVuY2UgYmV0 d2VlbiB0aGUgcGFnaW5nIAorCSAqIHRocmVzaG9sZCBhbmQgdGhlIGN1cnJlbnQgZnJlZSBtZW1v cnksIHdpdGggYSBtaW5pbXVtIG9mIDI1Nk1CLgorCSAqIFRoaXMgdGhyb3R0bGVzICJidXJzdCIg YWxsb2NhdGlvbnMgYW5kIHByZXZlbnRzIHRoZSBzeXN0ZW0gZnJvbSAKKwkgKiBjaG9raW5nIGR1 cmluZyB0aW1lcyBvZiBoaWdoIHdyaXRlIEkvTyBkZW1hbmQuCisgCSAqLworCWlmICh6aW9fdXNl X3VtYSkgeworCQl6ZnNfZGlydHlfZGF0YV9tYXggPSAxIDw8IDI4OworCQl6ZnNfZGlydHlfZGF0 YV9tYXggPSBNQVgoemZzX2RpcnR5X2RhdGFfbWF4LCBwdG9iKGNudC52X2ZyZWVfY291bnQgLSBj bnQudl9mcmVlX3RhcmdldCkpOworCQl6ZnNfZGlydHlfZGF0YV9tYXggPSBNSU4oemZzX2RpcnR5 X2RhdGFfbWF4LCBwdG9iKHBoeXNtZW0pICogemZzX2RpcnR5X2RhdGFfbWF4X3BlcmNlbnQgLyAx MDApOworCQl6ZnNfZGlydHlfZGF0YV9tYXggPSBNSU4oemZzX2RpcnR5X2RhdGFfbWF4LCB6ZnNf ZGlydHlfZGF0YV9tYXhfbWF4KTsKKwkJRFRSQUNFX1BST0JFMShkbXVfX3R4X2RpcnR5LCB1aW50 NjRfdCwgemZzX2RpcnR5X2RhdGFfbWF4IC8gKDEwMjQgKiAxMDI0KSk7CisJfQorI2VuZGlmCS8q IF9LRVJORUwgKi8KKwogCXdoaWxlICgoZXJyID0gZG11X3R4X3RyeV9hc3NpZ24odHgsIHR4Z19o b3cpKSAhPSAwKSB7CiAJCWRtdV90eF91bmFzc2lnbih0eCk7CiAKSW5kZXg6IHN5cy92bS92bV9w YWdlb3V0LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkocmV2aXNpb24gMjcx OTgxKQorKysgc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkod29ya2luZyBjb3B5KQpAQCAtNzYsNiArNzYs NyBAQAogX19GQlNESUQoIiRGcmVlQlNEJCIpOwogCiAjaW5jbHVkZSAib3B0X3ZtLmgiCisjaW5j bHVkZSAib3B0X2tkdHJhY2UuaCIKICNpbmNsdWRlIDxzeXMvcGFyYW0uaD4KICNpbmNsdWRlIDxz eXMvc3lzdG0uaD4KICNpbmNsdWRlIDxzeXMva2VybmVsLmg+CkBAIC04OSw2ICs5MCw3IEBAIF9f RkJTRElEKCIkRnJlZUJTRCQiKTsKICNpbmNsdWRlIDxzeXMvcmFjY3QuaD4KICNpbmNsdWRlIDxz eXMvcmVzb3VyY2V2YXIuaD4KICNpbmNsdWRlIDxzeXMvc2NoZWQuaD4KKyNpbmNsdWRlIDxzeXMv c2R0Lmg+CiAjaW5jbHVkZSA8c3lzL3NpZ25hbHZhci5oPgogI2luY2x1ZGUgPHN5cy9zbXAuaD4K ICNpbmNsdWRlIDxzeXMvdm5vZGUuaD4KQEAgLTExNSwxMCArMTE3LDE0IEBAIF9fRkJTRElEKCIk RnJlZUJTRCQiKTsKIAogLyogdGhlIGtlcm5lbCBwcm9jZXNzICJ2bV9wYWdlb3V0IiovCiBzdGF0 aWMgdm9pZCB2bV9wYWdlb3V0KHZvaWQpOworc3RhdGljIHZvaWQgdm1fcGFnZW91dF9pbml0KHZv aWQpOwogc3RhdGljIGludCB2bV9wYWdlb3V0X2NsZWFuKHZtX3BhZ2VfdCk7CiBzdGF0aWMgdm9p ZCB2bV9wYWdlb3V0X3NjYW4oc3RydWN0IHZtX2RvbWFpbiAqdm1kLCBpbnQgcGFzcyk7CiBzdGF0 aWMgdm9pZCB2bV9wYWdlb3V0X21pZ2h0YmVfb29tKHN0cnVjdCB2bV9kb21haW4gKnZtZCwgaW50 IHBhc3MpOwogCitTWVNJTklUKHBhZ2VkYWVtb25faW5pdCwgU0lfU1VCX0tUSFJFQURfUEFHRSwg U0lfT1JERVJfRklSU1QsIHZtX3BhZ2VvdXRfaW5pdCwKKyAgICBOVUxMKTsKKwogc3RydWN0IHBy b2MgKnBhZ2Vwcm9jOwogCiBzdGF0aWMgc3RydWN0IGtwcm9jX2Rlc2MgcGFnZV9rcCA9IHsKQEAg LTEyNiw5ICsxMzIsMTMgQEAgc3RhdGljIHN0cnVjdCBrcHJvY19kZXNjIHBhZ2Vfa3AgPSB7CiAJ dm1fcGFnZW91dCwKIAkmcGFnZXByb2MKIH07Ci1TWVNJTklUKHBhZ2VkYWVtb24sIFNJX1NVQl9L VEhSRUFEX1BBR0UsIFNJX09SREVSX0ZJUlNULCBrcHJvY19zdGFydCwKK1NZU0lOSVQocGFnZWRh ZW1vbiwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfU0VDT05ELCBrcHJvY19zdGFydCwK ICAgICAmcGFnZV9rcCk7CiAKK1NEVF9QUk9WSURFUl9ERUZJTkUodm0pOworU0RUX1BST0JFX0RF RklORSh2bSwgLCAsIHZtX19sb3dtZW1fY2FjaGUpOworU0RUX1BST0JFX0RFRklORSh2bSwgLCAs IHZtX19sb3dtZW1fc2Nhbik7CisKICNpZiAhZGVmaW5lZChOT19TV0FQUElORykKIC8qIHRoZSBr ZXJuZWwgcHJvY2VzcyAidm1fZGFlbW9uIiovCiBzdGF0aWMgdm9pZCB2bV9kYWVtb24odm9pZCk7 CkBAIC02NjMsNiArNjczLDcgQEAgdm1fcGFnZW91dF9ncm93X2NhY2hlKGludCB0cmllcywgdm1f cGFkZHJfdCBsb3csIHYKIAkJICogbWF5IGFjcXVpcmUgbG9ja3MgYW5kL29yIHNsZWVwLCBzbyB0 aGV5IGNhbiBvbmx5IGJlIGludm9rZWQKIAkJICogd2hlbiAidHJpZXMiIGlzIGdyZWF0ZXIgdGhh biB6ZXJvLgogCQkgKi8KKwkJU0RUX1BST0JFMCh2bSwgLCAsIHZtX19sb3dtZW1fY2FjaGUpOwog CQlFVkVOVEhBTkRMRVJfSU5WT0tFKHZtX2xvd21lbSwgMCk7CiAKIAkJLyoKQEAgLTkwNCw3ICs5 MTUsNyBAQCB2bV9wYWdlb3V0X21hcF9kZWFjdGl2YXRlX3BhZ2VzKG1hcCwgZGVzaXJlZCkKICAq CXBhc3MgMSAtIE1vdmUgaW5hY3RpdmUgdG8gY2FjaGUgb3IgZnJlZQogICoJcGFzcyAyIC0gTGF1 bmRlciBkaXJ0eSBwYWdlcwogICovCi1zdGF0aWMgdm9pZAorc3RhdGljIHZvaWQgX191c2VkCiB2 bV9wYWdlb3V0X3NjYW4oc3RydWN0IHZtX2RvbWFpbiAqdm1kLCBpbnQgcGFzcykKIHsKIAl2bV9w YWdlX3QgbSwgbmV4dDsKQEAgLTkyNSw2ICs5MzYsNyBAQCB2bV9wYWdlb3V0X3NjYW4oc3RydWN0 IHZtX2RvbWFpbiAqdm1kLCBpbnQgcGFzcykKIAkJLyoKIAkJICogRGVjcmVhc2UgcmVnaXN0ZXJl ZCBjYWNoZSBzaXplcy4KIAkJICovCisJCVNEVF9QUk9CRTAodm0sICwgLCB2bV9fbG93bWVtX3Nj YW4pOwogCQlFVkVOVEhBTkRMRVJfSU5WT0tFKHZtX2xvd21lbSwgMCk7CiAJCS8qCiAJCSAqIFdl IGRvIHRoaXMgZXhwbGljaXRseSBhZnRlciB0aGUgY2FjaGVzIGhhdmUgYmVlbgpAQCAtMTY1MCwx NSArMTY2MiwxMSBAQCB2bV9wYWdlb3V0X3dvcmtlcih2b2lkICphcmcpCiB9CiAKIC8qCi0gKgl2 bV9wYWdlb3V0IGlzIHRoZSBoaWdoIGxldmVsIHBhZ2VvdXQgZGFlbW9uLgorICoJdm1fcGFnZW91 dF9pbml0IGluaXRpYWxpc2VzIGJhc2ljIHBhZ2VvdXQgZGFlbW9uIHNldHRpbmdzLgogICovCiBz dGF0aWMgdm9pZAotdm1fcGFnZW91dCh2b2lkKQordm1fcGFnZW91dF9pbml0KHZvaWQpCiB7Ci0j aWYgTUFYTUVNRE9NID4gMQotCWludCBlcnJvciwgaTsKLSNlbmRpZgotCiAJLyoKIAkgKiBJbml0 aWFsaXplIHNvbWUgcGFnaW5nIHBhcmFtZXRlcnMuCiAJICovCkBAIC0xNzA0LDcgKzE3MTIsMTgg QEAgc3RhdGljIHZvaWQKIAkvKiBYWFggZG9lcyBub3QgcmVhbGx5IGJlbG9uZyBoZXJlICovCiAJ aWYgKHZtX3BhZ2VfbWF4X3dpcmVkID09IDApCiAJCXZtX3BhZ2VfbWF4X3dpcmVkID0gY250LnZf ZnJlZV9jb3VudCAvIDM7Cit9CiAKKy8qCisgKiAgICAgdm1fcGFnZW91dCBpcyB0aGUgaGlnaCBs ZXZlbCBwYWdlb3V0IGRhZW1vbi4KKyAqLworc3RhdGljIHZvaWQKK3ZtX3BhZ2VvdXQodm9pZCkK K3sKKyNpZiBNQVhNRU1ET00gPiAxCisJaW50IGVycm9yLCBpOworI2VuZGlmCisKIAlzd2FwX3Bh Z2VyX3N3YXBfaW5pdCgpOwogI2lmIE1BWE1FTURPTSA+IDEKIAlmb3IgKGkgPSAxOyBpIDwgdm1f bmRvbWFpbnM7IGkrKykgewo= 147609 2014-09-23 17:51:27 +0000 2014-09-23 17:51:27 +0000 dtrace script for the above kd-proveup.d text/plain 248 karl YXJjLWFsbG9jX2xvd21lbV9yZWFwCi9tYXJnaW4gPSBhcmcwIC0gYXJnMi8KewoJcHJpbnRmKCIl WSAlZCBmcmVlIHBhZ2VzLCAlZCB0YXJnZXQsICVkIHNpemUgcmVxLCAlZCBtYXJnaW4gKFJFQVAh KSIsIHdhbGx0aW1lc3RhbXAsIGFyZzAsIGFyZzIsIGFyZzEsIG1hcmdpbik7Cn0KCgovKiBkbXUt dHhfZGlydHkKewoJcHJpbnRmKCIlWSAlZCBNQiB6aW9fZGlydHlfZGF0YV9tYXgiLCB3YWxsdGlt ZXN0YW1wLCBhcmcwKTsKfSAqLwo= 147733 2014-09-27 20:10:27 +0000 2014-09-27 23:50:14 +0000 ARC reclaim refactor + uma clear down (against stable/10) arc_cache_reclaim_uma_stable10.patch text/plain 26750 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MjAwNSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMzQsNiArMzQs NyBAQCBfX0ZCU0RJRCgiJEZyZWVCU0QkIik7CiAjaW5jbHVkZSA8c3lzL2ttZW0uaD4KICNpbmNs dWRlIDxzeXMvZGVidWcuaD4KICNpbmNsdWRlIDxzeXMvbXV0ZXguaD4KKyNpbmNsdWRlIDxzeXMv c2R0Lmg+CiAKICNpbmNsdWRlIDx2bS92bV9wYWdlLmg+CiAjaW5jbHVkZSA8dm0vdm1fb2JqZWN0 Lmg+CkBAIC0xMzMsMTMgKzEzNCw2IEBAIGttZW1fc2l6ZSh2b2lkKQogCXJldHVybiAoa21lbV9z aXplX3ZhbCk7CiB9CiAKLXVpbnQ2NF90Ci1rbWVtX3VzZWQodm9pZCkKLXsKLQotCXJldHVybiAo dm1lbV9zaXplKGttZW1fYXJlbmEsIFZNRU1fQUxMT0MpKTsKLX0KLQogc3RhdGljIGludAoga21l bV9zdGRfY29uc3RydWN0b3Iodm9pZCAqbWVtLCBpbnQgc2l6ZSBfX3VudXNlZCwgdm9pZCAqcHJp dmF0ZSwgaW50IGZsYWdzKQogewpAQCAtMjI4LDEyICsyMjIsNDUgQEAga21lbV9jYWNoZV9yZWFw X25vdyhrbWVtX2NhY2hlX3QgKmNhY2hlKQogfQogCiB2b2lkCitrbWVtX2NhY2hlX3JlYXAoa21l bV9jYWNoZV90ICpjYWNoZSwgdWludDY0X3QgbWF4ZnJlZSkKK3sKKworCWlmIChjYWNoZS0+a2Nf em9uZSAhPSBOVUxMICYmCisJICAgIHVtYV96b25lX2ZyZWVfc2l6ZShjYWNoZS0+a2Nfem9uZSkg PiBtYXhmcmVlKQorCQl6b25lX2RyYWluKGNhY2hlLT5rY196b25lKTsKK30KKwordm9pZAoga21l bV9yZWFwKHZvaWQpCiB7CiAJdW1hX3JlY2xhaW0oKTsKIH0KKwordWludDY0X3QKK2ttZW1fY2Fj aGVfZnJlZV9zaXplKGttZW1fY2FjaGVfdCAqY2FjaGUpCit7CisJdWludDY0X3QgY2FjaGVmcmVl OworCisJY2FjaGVmcmVlID0gKGNhY2hlLT5rY196b25lID09IE5VTEwpID8gMCA6CisJICAgIHVt YV96b25lX2ZyZWVfc2l6ZShjYWNoZS0+a2Nfem9uZSk7CisKKwkvKgorCSAqIE1hbnVhbCBwcm9i ZSBhcyB0aGUgcmV0dXJuIGZidCBwcm9iZSBuZXZlciBmaXJlcyBkdWUgdG8KKwkgKiBjb21waWxl ciB0YWxsIGNhbGwgb3B0aW1pc2F0aW9uLgorCSAqLworCURUUkFDRV9QUk9CRTIoa21lbV9jYWNo ZV9mcmVlX3NpemUsIGNoYXIgKiwgY2FjaGUtPmtjX25hbWUsIHVpbnQ2NF90LAorCSAgICBjYWNo ZWZyZWUpOworCisJcmV0dXJuIChjYWNoZWZyZWUpOworfQorCiAjZWxzZQogdm9pZAora21lbV9j YWNoZV9yZWFwKGttZW1fY2FjaGVfdCAqY2FjaGUsIHVpbnQ2NF90IG1heGZyZWUpCit7Cit9CisK K3ZvaWQKIGttZW1fY2FjaGVfcmVhcF9ub3coa21lbV9jYWNoZV90ICpjYWNoZSBfX3VudXNlZCkK IHsKIH0KQEAgLTI0Miw2ICsyNjksMTEgQEAgdm9pZAoga21lbV9yZWFwKHZvaWQpCiB7CiB9CisK K3VpbnQ2NF90CitrbWVtX2NhY2hlX2ZyZWVfc2l6ZShrbWVtX2NhY2hlX3QgKmNhY2hlKQorewor fQogI2VuZGlmCiAKIGludApJbmRleDogc3lzL2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9r bWVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVt LmgJKHJldmlzaW9uIDI3MjAwNSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMv a21lbS5oCSh3b3JraW5nIGNvcHkpCkBAIC00NCw3ICs0NCw3IEBAIE1BTExPQ19ERUNMQVJFKE1f U09MQVJJUyk7CiAjZGVmaW5lCVBPSU5URVJfSU5WQUxJREFURShwcCkJKCoocHApID0gKHZvaWQg KikoKHVpbnRwdHJfdCkoKihwcCkpIHwgMHgxKSkKIAogI2RlZmluZQlLTV9TTEVFUAkJTV9XQUlU T0sKLSNkZWZpbmUJS01fUFVTSFBBR0UJCU1fV0FJVE9LCisjZGVmaW5lCUtNX1BVU0hQQUdFCQlN X1dBSVRPS3xNX1VTRV9SRVNFUlZFCiAjZGVmaW5lCUtNX05PU0xFRVAJCU1fTk9XQUlUCiAjZGVm aW5lCUtNX05PREVCVUcJCU1fTk9EVU1QCiAjZGVmaW5lCUtNX05PUk1BTFBSSQkJMApAQCAtNjYs NyArNjYsNiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZvaWQgKnpmc19rbWVtX2Fs bG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19rbWVtX2ZyZWUodm9pZCAq YnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9pZCk7Ci11aW50NjRfdCBr bWVtX3VzZWQodm9pZCk7CiBrbWVtX2NhY2hlX3QgKmttZW1fY2FjaGVfY3JlYXRlKGNoYXIgKm5h bWUsIHNpemVfdCBidWZzaXplLCBzaXplX3QgYWxpZ24sCiAgICAgaW50ICgqY29uc3RydWN0b3Ip KHZvaWQgKiwgdm9pZCAqLCBpbnQpLCB2b2lkICgqZGVzdHJ1Y3Rvcikodm9pZCAqLCB2b2lkICop LAogICAgIHZvaWQgKCpyZWNsYWltKSh2b2lkICopIF9fdW51c2VkLCB2b2lkICpwcml2YXRlLCB2 bWVtX3QgKnZtcCwgaW50IGNmbGFncyk7CkBAIC03NCwxMCArNzMsMTUgQEAgdm9pZCBrbWVtX2Nh Y2hlX2Rlc3Ryb3koa21lbV9jYWNoZV90ICpjYWNoZSk7CiB2b2lkICprbWVtX2NhY2hlX2FsbG9j KGttZW1fY2FjaGVfdCAqY2FjaGUsIGludCBmbGFncyk7CiB2b2lkIGttZW1fY2FjaGVfZnJlZShr bWVtX2NhY2hlX3QgKmNhY2hlLCB2b2lkICpidWYpOwogdm9pZCBrbWVtX2NhY2hlX3JlYXBfbm93 KGttZW1fY2FjaGVfdCAqY2FjaGUpOwordm9pZCBrbWVtX2NhY2hlX3JlYXAoa21lbV9jYWNoZV90 ICpjYWNoZSwgdWludDY0X3QgbWF4ZnJlZSk7CiB2b2lkIGttZW1fcmVhcCh2b2lkKTsKK3VpbnQ2 NF90IGttZW1fY2FjaGVfZnJlZV9zaXplKGttZW1fY2FjaGVfdCAqY2FjaGUpOwogaW50IGttZW1f ZGVidWdnaW5nKHZvaWQpOwogdm9pZCAqY2FsbG9jKHNpemVfdCBuLCBzaXplX3Qgcyk7CiAKKyNk ZWZpbmUJZnJlZW1lbQkJCQkoY250LnZfZnJlZV9jb3VudCArIGNudC52X2NhY2hlX2NvdW50KQor I2RlZmluZQltaW5mcmVlCQkJCWNudC52X2ZyZWVfbWluCisjZGVmaW5lCWhlYXBfYXJlbmEJCQlr bWVtX2FyZW5hCiAjZGVmaW5lCWttZW1fYWxsb2Moc2l6ZSwga21mbGFncykJemZzX2ttZW1fYWxs b2MoKHNpemUpLCAoa21mbGFncykpCiAjZGVmaW5lCWttZW1femFsbG9jKHNpemUsIGttZmxhZ3Mp CXpmc19rbWVtX2FsbG9jKChzaXplKSwgKGttZmxhZ3MpIHwgTV9aRVJPKQogI2RlZmluZQlrbWVt X2ZyZWUoYnVmLCBzaXplKQkJemZzX2ttZW1fZnJlZSgoYnVmKSwgKHNpemUpKQpJbmRleDogc3lz L2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9wYXJhbS5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9j ZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMvcGFyYW0uaAkocmV2aXNpb24gMjcyMDA1KQorKysg c3lzL2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9wYXJhbS5oCSh3b3JraW5nIGNvcHkpCkBA IC0zNiw2ICszNiw3IEBACiAKICNpZmRlZiBfS0VSTkVMCiAjZGVmaW5lCXB0b2IoeCkJCSgodWlu dDY0X3QpKHgpIDw8IFBBR0VfU0hJRlQpCisjZGVmaW5lCWJ0b3AoeCkJCSgodWludDY0X3QpKHgp ID4+IFBBR0VfU0hJRlQpCiAjZW5kaWYKIAogI2VuZGlmCkluZGV4OiBzeXMvY2RkbC9jb250cmli L29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9j ZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvYXJjLmMJKHJldmlzaW9u IDI3MjAwNSkKKysrIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96 ZnMvYXJjLmMJKHdvcmtpbmcgY29weSkKQEAgLTEzOCw2ICsxMzgsNyBAQAogI2luY2x1ZGUgPHN5 cy9zZHQuaD4KIAogI2luY2x1ZGUgPHZtL3ZtX3BhZ2VvdXQuaD4KKyNpbmNsdWRlIDxtYWNoaW5l L3ZtcGFyYW0uaD4KIAogI2lmZGVmIGlsbHVtb3MKICNpZm5kZWYgX0tFUk5FTApAQCAtMTU5LDYg KzE2MCwxNSBAQCB0eXBlZGVmIGVudW0gYXJjX3JlY2xhaW1fc3RyYXRlZ3kgewogCUFSQ19SRUNM QUlNX0NPTlMJCS8qIENvbnNlcnZhdGl2ZSByZWNsYWltIHN0cmF0ZWd5ICovCiB9IGFyY19yZWNs YWltX3N0cmF0ZWd5X3Q7CiAKK3R5cGVkZWYgZW51bSBhcmNfY2FjaGVfcmVjbGFpbV9zdHJhZ2Vn eSB7CisJQVJDX0NBQ0hFX1JFQ0xBSU1fTk9XLAkJLyogSW1tZWRpYXRlIHJlY2xhaW0gc3RyYXRl Z3kgKi8KKwlBUkNfQ0FDSEVfUkVDTEFJTV9TSVpFLAkJLyogRnJlZSBzaXplIHJlY2xhaW0gc3Ry YXRlZ3kgKi8KKwlBUkNfQ0FDSEVfUkVDTEFJTV9GT1JDRSwJLyogRm9yY2VkIGltbWVkaWF0ZSBy ZWNsYWltIHN0cmF0ZWd5ICovCit9IGFyY19jYWNoZV9yZWNsYWltX3N0cmF0ZWd5X3Q7CisKKy8q IFdoZW4gdGhlIGxhc3QgY2FjaGUgcmVjbGFpbSB3YXMgcHJvY2Vzc2VkLiAqLworc3RhdGljIGNs b2NrX3QgY2FjaGVfcmVjbGFpbV9sYXN0ID0gMDsKKwogLyoKICAqIFRoZSBudW1iZXIgb2YgaXRl cmF0aW9ucyB0aHJvdWdoIGFyY19ldmljdF8qKCkgYmVmb3JlIHdlCiAgKiBkcm9wICYgcmVhY3F1 aXJlIHRoZSBsb2NrLgpAQCAtMTkzLDkgKzIwMyw2IEBAIGV4dGVybiBpbnQgemZzX3ByZWZldGNo X2Rpc2FibGU7CiAgKi8KIHN0YXRpYyBib29sZWFuX3QgYXJjX3dhcm07CiAKLS8qCi0gKiBUaGVz ZSB0dW5hYmxlcyBhcmUgZm9yIHBlcmZvcm1hbmNlIGFuYWx5c2lzLgotICovCiB1aW50NjRfdCB6 ZnNfYXJjX21heDsKIHVpbnQ2NF90IHpmc19hcmNfbWluOwogdWludDY0X3QgemZzX2FyY19tZXRh X2xpbWl0ID0gMDsKQEAgLTIwNCw3ICsyMTEsMjcgQEAgaW50IHpmc19hcmNfc2hyaW5rX3NoaWZ0 ID0gMDsKIGludCB6ZnNfYXJjX3BfbWluX3NoaWZ0ID0gMDsKIGludCB6ZnNfZGlzYWJsZV9kdXBf ZXZpY3Rpb24gPSAwOwogdWludDY0X3QgemZzX2FyY19hdmVyYWdlX2Jsb2Nrc2l6ZSA9IDggKiAx MDI0OyAvKiA4S0IgKi8KK3VfaW50IHpmc19hcmNfZnJlZV90YXJnZXQgPSAwOwordV9pbnQgemZz X2FyY19jYWNoZV90YXJnZXQgPSAwOworaW50IHpmc19hcmNfY2FjaGVfcGVyaW9kID0gMTA7Citp bnQgemZzX2FyY19jYWNoZV9wYXJ0aWFsID0gMDsKK2ludCB6ZnNfYXJjX2NhY2hlX2ZyZWVfcGVy aW9kID0gMzAwOwordWludDY0X3QgemZzX2FyY19jYWNoZV9mcmVlX21heCA9ICgxIDw8MjQpOyAv KiAxNk1CICovCiAKKyNpZmRlZiBfS0VSTkVMCitzdGF0aWMgaW50IHN5c2N0bF92ZnNfemZzX2Fy Y19mcmVlX3RhcmdldChTWVNDVExfSEFORExFUl9BUkdTKTsKK3N0YXRpYyBpbnQgc3lzY3RsX3Zm c196ZnNfYXJjX2NhY2hlX3RhcmdldChTWVNDVExfSEFORExFUl9BUkdTKTsKKworc3RhdGljIHZv aWQKK2FyY190YXJnZXRfaW5pdCh2b2lkICp1bnVzZWQgX191bnVzZWQpCit7CisKKwl6ZnNfYXJj X2ZyZWVfdGFyZ2V0ID0gdm1fcGFnZW91dF93YWtldXBfdGhyZXNoOworCXpmc19hcmNfY2FjaGVf dGFyZ2V0ID0gKHZtX3BhZ2VvdXRfd2FrZXVwX3RocmVzaCAvIDIpICogMzsKK30KK1NZU0lOSVQo YXJjX3RhcmdldF9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9BTlksCisgICAg YXJjX3RhcmdldF9pbml0LCBOVUxMKTsKKwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19tYXgi LCAmemZzX2FyY19tYXgpOwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19taW4iLCAmemZzX2Fy Y19taW4pOwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19tZXRhX2xpbWl0IiwgJnpmc19hcmNf bWV0YV9saW1pdCk7CkBAIC0yMTcsNyArMjQ0LDc1IEBAIFNZU0NUTF9VUVVBRChfdmZzX3pmcywg T0lEX0FVVE8sIGFyY19taW4sIENUTEZMQUdfCiBTWVNDVExfVVFVQUQoX3Zmc196ZnMsIE9JRF9B VVRPLCBhcmNfYXZlcmFnZV9ibG9ja3NpemUsIENUTEZMQUdfUkRUVU4sCiAgICAgJnpmc19hcmNf YXZlcmFnZV9ibG9ja3NpemUsIDAsCiAgICAgIkFSQyBhdmVyYWdlIGJsb2Nrc2l6ZSIpOworU1lT Q1RMX0lOVChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19jYWNoZV9yZWNsYWltX3BlcmlvZCwgQ1RM RkxBR19SV1RVTiwKKyAgICAmemZzX2FyY19jYWNoZV9wZXJpb2QsIDAsCisgICAgIk1pbiBudW1i ZXIgb2Ygc2Vjb25kcyBiZXR3ZWVuIEFSQyBjYWNoZSByZWNsYWltcyIpOworU1lTQ1RMX1VJTlQo X3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfY2FjaGVfcmVjbGFpbV9wYXJ0aWFsLCBDVExGTEFHX1JX VFVOLAorICAgICZ6ZnNfYXJjX2NhY2hlX3BhcnRpYWwsIDAsCisgICAgIkVuYWJsZSBBUkMgdG8g cGVyZm9ybSBwYXJ0aWFsIGNhY2hlIHJlY2xhaW1zIik7CitTWVNDVExfVVFVQUQoX3Zmc196ZnMs IE9JRF9BVVRPLCBhcmNfY2FjaGVfZnJlZV9tYXgsIENUTEZMQUdfUldUVU4sCisgICAgJnpmc19h cmNfY2FjaGVfZnJlZV9tYXgsIDAsCisgICAgIk1heGltdW0gZnJlZSBieXRlcyBpbiBhbiBBUkMg Y2FjaGUgem9uZSBiZWZvcmUgcmVjbGFpbSB3aWxsIGJlIHRyaWdnZXJlZCIpOworU1lTQ1RMX1VJ TlQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfY2FjaGVfZnJlZV9wZXJpb2QsIENUTEZMQUdfUldU VU4sCisgICAgJnpmc19hcmNfY2FjaGVfZnJlZV9wZXJpb2QsIDAsCisgICAgIk1pbiBudW1iZXIg b2Ygc2Vjb25kcyBiZXR3ZWVuIEFSQyBmcmVlIHNpemUgYmFzZWQgY2FjaGUgcmVjbGFpbXMiKTsK Ky8qCisgKiBXZSBkb24ndCBoYXZlIGEgdHVuYWJsZSBmb3IgdGhlc2Ugc3lzY3RscyBkdWUgdG8g dGhlaXIgZGVwZW5kZW5jeSBvbgorICogcGFnZWRhZW1vbiBpbml0aWFsaXNhdGlvbi4KKyAqLwor U1lTQ1RMX1BST0MoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfZnJlZV90YXJnZXQsCisgICAgQ1RM VFlQRV9VSU5UIHwgQ1RMRkxBR19NUFNBRkUgfCBDVExGTEFHX1JXLCAwLCBzaXplb2YodV9pbnQp LAorICAgIHN5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldCwgIklVIiwKKyAgICAiRGVzaXJl ZCBudW1iZXIgb2YgZnJlZSBwYWdlcyBiZWxvdyB3aGljaCBBUkMgdHJpZ2dlcnMgcmVjbGFpbSIp OworU1lTQ1RMX1BST0MoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfY2FjaGVfdGFyZ2V0LAorICAg IENUTFRZUEVfVUlOVCB8IENUTEZMQUdfTVBTQUZFIHwgQ1RMRkxBR19SVywgMCwgc2l6ZW9mKHVf aW50KSwKKyAgICBzeXNjdGxfdmZzX3pmc19hcmNfY2FjaGVfdGFyZ2V0LCAiSVUiLAorICAgICJE ZXNpcmVkIG51bWJlciBvZiBmcmVlIHBhZ2VzIGJlbG93IHdoaWNoIEFSQyB0cmlnZ2VycyBjYWNo ZSByZWNsYWltIik7CiAKKworc3RhdGljIGludAorc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFy Z2V0KFNZU0NUTF9IQU5ETEVSX0FSR1MpCit7CisJdV9pbnQgdmFsOworCWludCBlcnI7CisKKwl2 YWwgPSB6ZnNfYXJjX2ZyZWVfdGFyZ2V0OworCWVyciA9IHN5c2N0bF9oYW5kbGVfaW50KG9pZHAs ICZ2YWwsIDAsIHJlcSk7CisJaWYgKGVyciAhPSAwIHx8IHJlcS0+bmV3cHRyID09IE5VTEwpCisJ CXJldHVybiAoZXJyKTsKKworCWlmICh2YWwgPCBtaW5mcmVlKQorCQlyZXR1cm4gKEVJTlZBTCk7 CisJaWYgKHZhbCA+IGNudC52X3BhZ2VfY291bnQpCisJCXJldHVybiAoRUlOVkFMKTsKKworCXpm c19hcmNfZnJlZV90YXJnZXQgPSB2YWw7CisKKwlyZXR1cm4gKDApOworfQorCitzdGF0aWMgaW50 CitzeXNjdGxfdmZzX3pmc19hcmNfY2FjaGVfdGFyZ2V0KFNZU0NUTF9IQU5ETEVSX0FSR1MpCit7 CisJdV9pbnQgdmFsOworCWludCBlcnI7CisKKwl2YWwgPSB6ZnNfYXJjX2NhY2hlX3RhcmdldDsK KwllcnIgPSBzeXNjdGxfaGFuZGxlX2ludChvaWRwLCAmdmFsLCAwLCByZXEpOworCWlmIChlcnIg IT0gMCB8fCByZXEtPm5ld3B0ciA9PSBOVUxMKQorCQlyZXR1cm4gKGVycik7CisKKwlpZiAodmFs IDwgbWluZnJlZSkKKwkJcmV0dXJuIChFSU5WQUwpOworCWlmICh2YWwgPiBjbnQudl9wYWdlX2Nv dW50KQorCQlyZXR1cm4gKEVJTlZBTCk7CisKKwl6ZnNfYXJjX2NhY2hlX3RhcmdldCA9IHZhbDsK KworCXJldHVybiAoMCk7Cit9CisjZW5kaWYKKwogLyoKICAqIE5vdGUgdGhhdCBidWZmZXJzIGNh biBiZSBpbiBvbmUgb2YgNiBzdGF0ZXM6CiAgKglBUkNfYW5vbgktIGFub255bW91cyAoZGlzY3Vz c2VkIGJlbG93KQpAQCAtNTkyLDYgKzY4NywxMyBAQCBzdGF0aWMgdm9pZCBhcmNfZXZpY3RfZ2hv c3QoYXJjX3N0YXRlX3QgKnN0YXRlLCB1aQogc3RhdGljIHZvaWQgYXJjX2J1Zl93YXRjaChhcmNf YnVmX3QgKmJ1Zik7CiAjZW5kaWYgLyogaWxsdW1vcyAqLwogCitzdGF0aWMgdWludDY0X3QgYXJj X2NhY2hlX2ZyZWUodm9pZCk7CitzdGF0aWMgYm9vbGVhbl90IGFyY19jYWNoZV9yZWNsYWltX25l ZWRlZCh1aW50NjRfdCBzaXplKTsKK3N0YXRpYyBib29sZWFuX3QgYXJjX2NhY2hlX3JlY2xhaW0o dWludDY0X3Qgc2l6ZSwKKyAgICBhcmNfY2FjaGVfcmVjbGFpbV9zdHJhdGVneV90IHN0cmF0KTsK K3N0YXRpYyBib29sZWFuX3QgYXJjX2NhY2hlX3JlY2xhaW1fc3RyYXQoa21lbV9jYWNoZV90ICpj YWNoZSwgdWludDY0X3Qgc2l6ZSwKKyAgICBhcmNfY2FjaGVfcmVjbGFpbV9zdHJhdGVneV90IHN0 cmF0KTsKKwogc3RhdGljIGJvb2xlYW5fdCBsMmFyY193cml0ZV9lbGlnaWJsZSh1aW50NjRfdCBz cGFfZ3VpZCwgYXJjX2J1Zl9oZHJfdCAqYWIpOwogCiAjZGVmaW5lCUdIT1NUX1NUQVRFKHN0YXRl KQlcCkBAIC0yNDIxLDYgKzI1MjMsNyBAQCBhcmNfZmx1c2goc3BhX3QgKnNwYSkKIHZvaWQKIGFy Y19zaHJpbmsodm9pZCkKIHsKKwogCWlmIChhcmNfYyA+IGFyY19jX21pbikgewogCQl1aW50NjRf dCB0b19mcmVlOwogCkBAIC0yNDI5LDYgKzI1MzIsOSBAQCBhcmNfc2hyaW5rKHZvaWQpCiAjZWxz ZQogCQl0b19mcmVlID0gYXJjX2MgPj4gYXJjX3Nocmlua19zaGlmdDsKICNlbmRpZgorCQlEVFJB Q0VfUFJPQkU0KGFyY19fc2hyaW5rLCB1aW50NjRfdCwgYXJjX2MsIHVpbnQ2NF90LAorCQkJYXJj X2NfbWluLCB1aW50NjRfdCwgYXJjX3AsIHVpbnQ2NF90LCB0b19mcmVlKTsKKwogCQlpZiAoYXJj X2MgPiBhcmNfY19taW4gKyB0b19mcmVlKQogCQkJYXRvbWljX2FkZF82NCgmYXJjX2MsIC10b19m cmVlKTsKIAkJZWxzZQpAQCAtMjQzOSwxMiArMjU0NSwxOSBAQCBhcmNfc2hyaW5rKHZvaWQpCiAJ CQlhcmNfYyA9IE1BWChhcmNfc2l6ZSwgYXJjX2NfbWluKTsKIAkJaWYgKGFyY19wID4gYXJjX2Mp CiAJCQlhcmNfcCA9IChhcmNfYyA+PiAxKTsKKworCQlEVFJBQ0VfUFJPQkUyKGFyY19fc2hydW5r LCB1aW50NjRfdCwgYXJjX2MsIHVpbnQ2NF90LAorCQkJYXJjX3ApOworCiAJCUFTU0VSVChhcmNf YyA+PSBhcmNfY19taW4pOwogCQlBU1NFUlQoKGludDY0X3QpYXJjX3AgPj0gMCk7CiAJfQogCi0J aWYgKGFyY19zaXplID4gYXJjX2MpCisJaWYgKGFyY19zaXplID4gYXJjX2MpIHsKKwkJRFRSQUNF X1BST0JFMihhcmNfX3Nocmlua19hZGp1c3QsIHVpbnQ2NF90LCBhcmNfc2l6ZSwKKwkJCXVpbnQ2 NF90LCBhcmNfYyk7CiAJCWFyY19hZGp1c3QoKTsKKwl9CiB9CiAKIHN0YXRpYyBpbnQgbmVlZGZy ZWUgPSAwOwpAQCAtMjQ1NCwxNiArMjU2NywyNiBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkK IHsKIAogI2lmZGVmIF9LRVJORUwKKwlpZiAoYXJjX3NpemUgPD0gYXJjX2NfbWluKSB7CisJCURU UkFDRV9QUk9CRTIoYXJjX19yZWNsYWltX21pbiwgdWludDY0X3QsIGFyY19zaXplLAorCQkgICAg dWludDY0X3QsIGFyY19jX21pbik7CisJCXJldHVybiAoMCk7CisJfQogCi0JaWYgKG5lZWRmcmVl KQorCWlmIChuZWVkZnJlZSkgeworCQlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX25lZWRmcmVl KTsKIAkJcmV0dXJuICgxKTsKKwl9CiAKIAkvKgogCSAqIENvb3BlcmF0ZSB3aXRoIHBhZ2VkYWVt b24gd2hlbiBpdCdzIHRpbWUgZm9yIGl0IHRvIHNjYW4KIAkgKiBhbmQgcmVjbGFpbSBzb21lIHBh Z2VzLgogCSAqLwotCWlmICh2bV9wYWdpbmdfbmVlZGVkKCkpCisJaWYgKGZyZWVtZW0gPCB6ZnNf YXJjX2ZyZWVfdGFyZ2V0KSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19yZWNsYWltX2ZyZWVtZW0s IHVpbnQ2NF90LAorCQkgICAgZnJlZW1lbSwgdWludDY0X3QsIHpmc19hcmNfZnJlZV90YXJnZXQp OwogCQlyZXR1cm4gKDEpOworCX0KIAogI2lmZGVmIHN1bgogCS8qCkBAIC0yNDkxLDggKzI2MTQs MTkgQEAgYXJjX3JlY2xhaW1fbmVlZGVkKHZvaWQpCiAJaWYgKGF2YWlscm1lbSA8IHN3YXBmc19t aW5mcmVlICsgc3dhcGZzX3Jlc2VydmUgKyBleHRyYSkKIAkJcmV0dXJuICgxKTsKIAotI2lmIGRl ZmluZWQoX19pMzg2KQogCS8qCisJICogQ2hlY2sgdGhhdCB3ZSBoYXZlIGVub3VnaCBhdmFpbHJt ZW0gdGhhdCBtZW1vcnkgbG9ja2luZyAoZS5nLiwgdmlhCisJICogbWxvY2soM0MpIG9yIG1lbWNu dGwoMikpIGNhbiBzdGlsbCBzdWNjZWVkLiAgKHBhZ2VzX3BwX21heGltdW0KKwkgKiBzdG9yZXMg dGhlIG51bWJlciBvZiBwYWdlcyB0aGF0IGNhbm5vdCBiZSBsb2NrZWQ7IHdoZW4gYXZhaWxybWVt CisJICogZHJvcHMgYmVsb3cgcGFnZXNfcHBfbWF4aW11bSwgcGFnZSBsb2NraW5nIG1lY2hhbmlz bXMgc3VjaCBhcworCSAqIHBhZ2VfcHBfbG9jaygpIHdpbGwgZmFpbC4pCisJICovCisJaWYgKGF2 YWlscm1lbSA8PSBwYWdlc19wcF9tYXhpbXVtKQorCQlyZXR1cm4gKDEpOworCisjZW5kaWYJLyog c3VuICovCisjaWYgZGVmaW5lZChfX2kzODYpIHx8ICFkZWZpbmVkKFVNQV9NRF9TTUFMTF9BTExP QykKKwkvKgogCSAqIElmIHdlJ3JlIG9uIGFuIGkzODYgcGxhdGZvcm0sIGl0J3MgcG9zc2libGUg dGhhdCB3ZSdsbCBleGhhdXN0IHRoZQogCSAqIGtlcm5lbCBoZWFwIHNwYWNlIGJlZm9yZSB3ZSBl dmVyIHJ1biBvdXQgb2YgYXZhaWxhYmxlIHBoeXNpY2FsCiAJICogbWVtb3J5LiAgTW9zdCBjaGVj a3Mgb2YgdGhlIHNpemUgb2YgdGhlIGhlYXBfYXJlYSBjb21wYXJlIGFnYWluc3QKQEAgLTI1MDMs MjYgKzI2MzcsNDMgQEAgYXJjX3JlY2xhaW1fbmVlZGVkKHZvaWQpCiAJICogaGVhcCBpcyBhbGxv Y2F0ZWQuICAoT3IsIGluIHRoZSBjYWxjdWxhdGlvbiwgaWYgbGVzcyB0aGFuIDEvNHRoIGlzCiAJ ICogZnJlZSkKIAkgKi8KLQlpZiAoYnRvcCh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVF KSkgPAotCSAgICAoYnRvcCh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwgVk1FTV9B TExPQykpID4+IDIpKQorCWlmICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSA8CisJ ICAgICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwgVk1FTV9BTExPQykgPj4gMikp IHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fdXNlZCwgdWludDY0X3QsCisJCSAgICB2 bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSwgdWludDY0X3QsCisJCSAgICAodm1lbV9z aXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+PiAyKTsKIAkJcmV0dXJu ICgxKTsKKwl9CiAjZW5kaWYKLSNlbHNlCS8qICFzdW4gKi8KLQlpZiAoa21lbV91c2VkKCkgPiAo a21lbV9zaXplKCkgKiAzKSAvIDQpCisjaWZkZWYgc3VuCisJLyoKKwkgKiBJZiB6aW8gZGF0YSBw YWdlcyBhcmUgYmVpbmcgYWxsb2NhdGVkIG91dCBvZiBhIHNlcGFyYXRlIGhlYXAgc2VnbWVudCwK KwkgKiB0aGVuIGVuZm9yY2UgdGhhdCB0aGUgc2l6ZSBvZiBhdmFpbGFibGUgdm1lbSBmb3IgdGhp cyBhcmVuYSByZW1haW5zCisJICogYWJvdmUgYWJvdXQgMS8xNnRoIGZyZWUuCisJICoKKwkgKiBO b3RlOiBUaGUgMS8xNnRoIGFyZW5hIGZyZWUgcmVxdWlyZW1lbnQgd2FzIHB1dCBpbiBwbGFjZQor CSAqIHRvIGFnZ3Jlc3NpdmVseSBldmljdCBtZW1vcnkgZnJvbSB0aGUgYXJjIGluIG9yZGVyIHRv IGF2b2lkCisJICogbWVtb3J5IGZyYWdtZW50YXRpb24gaXNzdWVzLgorCSAqLworCWlmICh6aW9f YXJlbmEgIT0gTlVMTCAmJgorCSAgICB2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0ZSRUUpIDwK KwkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fQUxMT0MpID4+IDQpKQogCQlyZXR1cm4g KDEpOwogI2VuZGlmCS8qIHN1biAqLwotCi0jZWxzZQorI2Vsc2UJLyogX0tFUk5FTCAqLwogCWlm IChzcGFfZ2V0X3JhbmRvbSgxMDApID09IDApCiAJCXJldHVybiAoMSk7Ci0jZW5kaWYKKyNlbmRp ZgkvKiBfS0VSTkVMICovCisJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9ubyk7CisKIAlyZXR1 cm4gKDApOwogfQogCiBleHRlcm4ga21lbV9jYWNoZV90CSp6aW9fYnVmX2NhY2hlW107CiBleHRl cm4ga21lbV9jYWNoZV90CSp6aW9fZGF0YV9idWZfY2FjaGVbXTsKK2V4dGVybiBrbWVtX2NhY2hl X3QJKnJhbmdlX3NlZ19jYWNoZTsKIAotc3RhdGljIHZvaWQKK3N0YXRpYyB2b2lkIF9fbm9pbmxp bmUKIGFyY19rbWVtX3JlYXBfbm93KGFyY19yZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiB7CiAJ c2l6ZV90CQkJaTsKQEAgLTI1MjksNiArMjY4MCw3IEBAIGFyY19rbWVtX3JlYXBfbm93KGFyY19y ZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJa21lbV9jYWNoZV90CQkqcHJldl9jYWNoZSA9IE5V TEw7CiAJa21lbV9jYWNoZV90CQkqcHJldl9kYXRhX2NhY2hlID0gTlVMTDsKIAorCURUUkFDRV9Q Uk9CRShhcmNfX2ttZW1fcmVhcF9zdGFydCk7CiAjaWZkZWYgX0tFUk5FTAogCWlmIChhcmNfbWV0 YV91c2VkID49IGFyY19tZXRhX2xpbWl0KSB7CiAJCS8qCkBAIC0yNTM3LDcgKzI2ODksNyBAQCBh cmNfa21lbV9yZWFwX25vdyhhcmNfcmVjbGFpbV9zdHJhdGVneV90IHN0cmF0KQogCQkgKi8KIAkJ ZG5sY19yZWR1Y2VfY2FjaGUoKHZvaWQgKikodWludHB0cl90KWFyY19yZWR1Y2VfZG5sY19wZXJj ZW50KTsKIAl9Ci0jaWYgZGVmaW5lZChfX2kzODYpCisjaWYgZGVmaW5lZChfX2kzODYpIHx8ICFk ZWZpbmVkKFVNQV9NRF9TTUFMTF9BTExPQykKIAkvKgogCSAqIFJlY2xhaW0gdW51c2VkIG1lbW9y eSBmcm9tIGFsbCBrbWVtIGNhY2hlcy4KIAkgKi8KQEAgLTI1NTIsMjAgKzI3MDQsMTI3IEBAIGFy Y19rbWVtX3JlYXBfbm93KGFyY19yZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJaWYgKHN0cmF0 ID09IEFSQ19SRUNMQUlNX0FHR1IpCiAJCWFyY19zaHJpbmsoKTsKIAorCSh2b2lkKSBhcmNfY2Fj aGVfcmVjbGFpbSgwLCBBUkNfQ0FDSEVfUkVDTEFJTV9GT1JDRSk7CisKKyNpZmRlZiBzdW4KKwkv KgorCSAqIEFzayB0aGUgdm1lbSBhcmVhbmEgdG8gcmVjbGFpbSB1bnVzZWQgbWVtb3J5IGZyb20g aXRzCisJICogcXVhbnR1bSBjYWNoZXMuCisJICovCisJaWYgKHppb19hcmVuYSAhPSBOVUxMICYm IHN0cmF0ID09IEFSQ19SRUNMQUlNX0FHR1IpCisJCXZtZW1fcWNhY2hlX3JlYXAoemlvX2FyZW5h KTsKKyNlbmRpZgorb3V0OgorCURUUkFDRV9QUk9CRShhcmNfX2ttZW1fcmVhcF9lbmQpOworfQor CisKK3N0YXRpYyBib29sZWFuX3QKK2FyY19jYWNoZV9yZWNsYWltX25lZWRlZCh1aW50NjRfdCBz aXplKQoreworCisJaWYgKHpmc19hcmNfY2FjaGVfdGFyZ2V0ICYmIGZyZWVtZW0gPCB6ZnNfYXJj X2NhY2hlX3RhcmdldCArIGJ0b3Aoc2l6ZSkpIHsKKwkJRFRSQUNFX1BST0JFMShhcmNfY2FjaGVf cmVjbGFpbV9uZWVkZWQsIGludCwgQl9UUlVFKTsKKwkJcmV0dXJuIChCX1RSVUUpOworCX0KKwor CURUUkFDRV9QUk9CRTEoYXJjX2NhY2hlX3JlY2xhaW1fbmVlZGVkLCBpbnQsIEJfRkFMU0UpOwor CXJldHVybiAoQl9GQUxTRSk7Cit9CisKK3N0YXRpYyBib29sZWFuX3QKK2FyY19jYWNoZV9yZWNs YWltX3N0cmF0KGttZW1fY2FjaGVfdCAqY2FjaGUsIHVpbnQ2NF90IHNpemUsCisgICAgYXJjX2Nh Y2hlX3JlY2xhaW1fc3RyYXRlZ3lfdCBzdHJhdCkKK3sKKworCXN3aXRjaChzdHJhdCkgeworCWNh c2UgQVJDX0NBQ0hFX1JFQ0xBSU1fTk9XOgorCWNhc2UgQVJDX0NBQ0hFX1JFQ0xBSU1fRk9SQ0U6 CisJCWttZW1fY2FjaGVfcmVhcF9ub3coY2FjaGUpOworCQlpZiAoemZzX2FyY19jYWNoZV9wYXJ0 aWFsICYmICFhcmNfY2FjaGVfcmVjbGFpbV9uZWVkZWQoc2l6ZSkpCisJCQlyZXR1cm4gKEJfVFJV RSk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWttZW1fY2FjaGVfcmVhcChjYWNoZSwgemZzX2Fy Y19jYWNoZV9mcmVlX21heCk7CisJfQorCisJcmV0dXJuIChCX0ZBTFNFKTsKK30KKworc3RhdGlj IGJvb2xlYW5fdAorYXJjX2NhY2hlX3JlY2xhaW0odWludDY0X3Qgc2l6ZSwgYXJjX2NhY2hlX3Jl Y2xhaW1fc3RyYXRlZ3lfdCBzdHJhdCkKK3sKKwlpbnQgaTsKKwljbG9ja190IG5vdzsKKwlrbWVt X2NhY2hlX3QgKnByZXZfY2FjaGUsICpwcmV2X2RhdGFfY2FjaGU7CisKKwlub3cgPSBkZGlfZ2V0 X2xib2x0KCk7CisJRFRSQUNFX1BST0JFMyhhcmNfY2FjaGVfcmVjbGFpbV90ZXN0LCBpbnQsIHN0 cmF0LCBpbnQ2NF90LCBub3csCisJICAgIGludDY0X3QsIGNhY2hlX3JlY2xhaW1fbGFzdCk7CisJ aWYgKG5vdyAtIGNhY2hlX3JlY2xhaW1fbGFzdCA+ICh6ZnNfYXJjX2NhY2hlX3BlcmlvZCAqIGh6 KSkKKwkJcmV0dXJuIChCX0ZBTFNFKTsKKworCURUUkFDRV9QUk9CRTEoYXJjX2NhY2hlX3JlY2xh aW0sIGludCwgc3RyYXQpOworCiAJZm9yIChpID0gMDsgaSA8IFNQQV9NQVhCTE9DS1NJWkUgPj4g U1BBX01JTkJMT0NLU0hJRlQ7IGkrKykgewogCQlpZiAoemlvX2J1Zl9jYWNoZVtpXSAhPSBwcmV2 X2NhY2hlKSB7CiAJCQlwcmV2X2NhY2hlID0gemlvX2J1Zl9jYWNoZVtpXTsKLQkJCWttZW1fY2Fj aGVfcmVhcF9ub3coemlvX2J1Zl9jYWNoZVtpXSk7CisJCQlpZiAoYXJjX2NhY2hlX3JlY2xhaW1f c3RyYXQoemlvX2J1Zl9jYWNoZVtpXSwgc2l6ZSwKKwkJCSAgICBzdHJhdCkpIHsKKwkJCQlyZXR1 cm4gKEJfVFJVRSk7CisJCQl9CisKIAkJfQogCQlpZiAoemlvX2RhdGFfYnVmX2NhY2hlW2ldICE9 IHByZXZfZGF0YV9jYWNoZSkgewogCQkJcHJldl9kYXRhX2NhY2hlID0gemlvX2RhdGFfYnVmX2Nh Y2hlW2ldOwotCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6aW9fZGF0YV9idWZfY2FjaGVbaV0pOwor CQkJaWYgKGFyY19jYWNoZV9yZWNsYWltX3N0cmF0KHppb19kYXRhX2J1Zl9jYWNoZVtpXSwKKwkJ CSAgICBzaXplLCBzdHJhdCkpCisJCQkJcmV0dXJuIChCX1RSVUUpOwogCQl9CiAJfQotCWttZW1f Y2FjaGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKLQlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9jYWNo ZSk7CisJaWYgKGFyY19jYWNoZV9yZWNsYWltX3N0cmF0KHJhbmdlX3NlZ19jYWNoZSwgc2l6ZSwg c3RyYXQpKQorCQlyZXR1cm4gKEJfVFJVRSk7CisKKwlpZiAoYXJjX2NhY2hlX3JlY2xhaW1fc3Ry YXQoYnVmX2NhY2hlLCBzaXplLCBzdHJhdCkpCisJCXJldHVybiAoQl9UUlVFKTsKKworCWFyY19j YWNoZV9yZWNsYWltX3N0cmF0KGhkcl9jYWNoZSwgc2l6ZSwgc3RyYXQpOworCisJY2FjaGVfcmVj bGFpbV9sYXN0ID0gZGRpX2dldF9sYm9sdCgpOworCisJaWYgKGFyY19jYWNoZV9yZWNsYWltX25l ZWRlZChzaXplKSkKKwkJcmV0dXJuIChCX0ZBTFNFKTsKKworCXJldHVybiAoQl9UUlVFKTsKIH0K IAorc3RhdGljIHVpbnQ2NF90CithcmNfY2FjaGVfZnJlZSh2b2lkKQoreworCWludCBpOworCXVp bnQ2NF90IGNhY2hlZnJlZTsKKwlrbWVtX2NhY2hlX3QgKnByZXZfY2FjaGUsICpwcmV2X2RhdGFf Y2FjaGU7CisKKwljYWNoZWZyZWUgPSBrbWVtX2NhY2hlX2ZyZWVfc2l6ZShidWZfY2FjaGUpICsK KwkgICAga21lbV9jYWNoZV9mcmVlX3NpemUoaGRyX2NhY2hlKTsKKworCXByZXZfY2FjaGUgPSBO VUxMOworCXByZXZfZGF0YV9jYWNoZSA9IE5VTEw7CisKKyAgICAgICAgZm9yIChpID0gMDsgaSA8 IFNQQV9NQVhCTE9DS1NJWkUgPj4gU1BBX01JTkJMT0NLU0hJRlQ7IGkrKykgeworICAgICAgICAg ICAgICAgIGlmICh6aW9fYnVmX2NhY2hlW2ldICE9IHByZXZfY2FjaGUpIHsKKyAgICAgICAgICAg ICAgICAgICAgICAgIHByZXZfY2FjaGUgPSB6aW9fYnVmX2NhY2hlW2ldOworICAgICAgICAgICAg ICAgICAgICAgICAgY2FjaGVmcmVlICs9IGttZW1fY2FjaGVfZnJlZV9zaXplKHppb19idWZfY2Fj aGVbaV0pOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICBpZiAoemlvX2RhdGFf YnVmX2NhY2hlW2ldICE9IHByZXZfZGF0YV9jYWNoZSkgeworICAgICAgICAgICAgICAgICAgICAg ICAgcHJldl9kYXRhX2NhY2hlID0gemlvX2RhdGFfYnVmX2NhY2hlW2ldOworICAgICAgICAgICAg ICAgICAgICAgICAgY2FjaGVmcmVlICs9IGttZW1fY2FjaGVfZnJlZV9zaXplKHppb19kYXRhX2J1 Zl9jYWNoZVtpXSk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICB9CisKKwlyZXR1cm4gKGNh Y2hlZnJlZSk7Cit9CisKIHN0YXRpYyB2b2lkCiBhcmNfcmVjbGFpbV90aHJlYWQodm9pZCAqZHVt bXkgX191bnVzZWQpCiB7CkBAIC0yNTc3LDEwICsyODM2LDI4IEBAIGFyY19yZWNsYWltX3RocmVh ZCh2b2lkICpkdW1teSBfX3VudXNlZCkKIAogCW11dGV4X2VudGVyKCZhcmNfcmVjbGFpbV90aHJf bG9jayk7CiAJd2hpbGUgKGFyY190aHJlYWRfZXhpdCA9PSAwKSB7CisJCURUUkFDRV9QUk9CRShh cmNfX3JlY2xhaW1fdGhyZWFkKTsKKwkJaWYgKGFyY19jYWNoZV9yZWNsYWltX25lZWRlZCgwKSkg eworCQkJKHZvaWQpIGFyY19jYWNoZV9yZWNsYWltKDAsIEFSQ19DQUNIRV9SRUNMQUlNX05PVyk7 CisJCX0gZWxzZSB7CisJCQljbG9ja190IG5vdzsKKworCQkJbm93ID0gZGRpX2dldF9sYm9sdCgp OworCQkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fY2hlY2ssIGludDY0X3QsIG5vdywKKwkJ CQlpbnQ2NF90LCBjYWNoZV9yZWNsYWltX2xhc3QpOworCQkJaWYgKG5vdyAtIGNhY2hlX3JlY2xh aW1fbGFzdCA+CisJCQkgICAgKHpmc19hcmNfY2FjaGVfZnJlZV9wZXJpb2QgKiBoeikpIHsKKwkJ CQkodm9pZCkgYXJjX2NhY2hlX3JlY2xhaW0oMCwKKwkJCQkgICAgQVJDX0NBQ0hFX1JFQ0xBSU1f U0laRSk7CisJCQl9CisJCX0KKwogCQlpZiAoYXJjX3JlY2xhaW1fbmVlZGVkKCkpIHsKLQorCQkJ RFRSQUNFX1BST0JFMShhcmNfX2NhY2hlc19mcmVlLCB1aW50NjRfdCwKKwkJCSAgICBhcmNfY2Fj aGVfZnJlZSgpKTsKIAkJCWlmIChhcmNfbm9fZ3JvdykgewogCQkJCWlmIChsYXN0X3JlY2xhaW0g PT0gQVJDX1JFQ0xBSU1fQ09OUykgeworCQkJCQlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX2Fn Z3Jfbm9fZ3Jvdyk7CiAJCQkJCWxhc3RfcmVjbGFpbSA9IEFSQ19SRUNMQUlNX0FHR1I7CiAJCQkJ fSBlbHNlIHsKIAkJCQkJbGFzdF9yZWNsYWltID0gQVJDX1JFQ0xBSU1fQ09OUzsKQEAgLTI1ODgs NiArMjg2NSw3IEBAIGFyY19yZWNsYWltX3RocmVhZCh2b2lkICpkdW1teSBfX3VudXNlZCkKIAkJ CX0gZWxzZSB7CiAJCQkJYXJjX25vX2dyb3cgPSBUUlVFOwogCQkJCWxhc3RfcmVjbGFpbSA9IEFS Q19SRUNMQUlNX0FHR1I7CisJCQkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9hZ2dyKTsKIAkJ CQltZW1iYXJfcHJvZHVjZXIoKTsKIAkJCX0KIApAQCAtMjYwMiw2ICsyODgwLDcgQEAgYXJjX3Jl Y2xhaW1fdGhyZWFkKHZvaWQgKmR1bW15IF9fdW51c2VkKQogCQkJCSAqLwogCQkJCWFyY19ub19n cm93ID0gVFJVRTsKIAkJCQlsYXN0X3JlY2xhaW0gPSBBUkNfUkVDTEFJTV9BR0dSOworCQkJCURU UkFDRV9QUk9CRShhcmNfX3JlY2xhaW1fYWdncl9uZWVkZnJlZSk7CiAJCQl9CiAJCQlhcmNfa21l bV9yZWFwX25vdyhsYXN0X3JlY2xhaW0pOwogCQkJYXJjX3dhcm0gPSBCX1RSVUU7CkBAIC0yNjE4 LDYgKzI4OTcsNyBAQCBhcmNfcmVjbGFpbV90aHJlYWQodm9pZCAqZHVtbXkgX191bnVzZWQpCiAj aWZkZWYgX0tFUk5FTAogCQlpZiAobmVlZGZyZWUpIHsKIAkJCW5lZWRmcmVlID0gMDsKKwkJCURU UkFDRV9QUk9CRShhcmNfX2NsZWFyX25lZWRmcmVlKTsKIAkJCXdha2V1cCgmbmVlZGZyZWUpOwog CQl9CiAjZW5kaWYKQEAgLTI2OTIsNiArMjk3Miw3IEBAIGFyY19hZGFwdChpbnQgYnl0ZXMsIGFy Y19zdGF0ZV90ICpzdGF0ZSkKIAkgKiBjYWNoZSBzaXplLCBpbmNyZW1lbnQgdGhlIHRhcmdldCBj YWNoZSBzaXplCiAJICovCiAJaWYgKGFyY19zaXplID4gYXJjX2MgLSAoMlVMTCA8PCBTUEFfTUFY QkxPQ0tTSElGVCkpIHsKKwkJRFRSQUNFX1BST0JFMShhcmNfX2luY19hZGFwdCwgaW50LCBieXRl cyk7CiAJCWF0b21pY19hZGRfNjQoJmFyY19jLCAoaW50NjRfdClieXRlcyk7CiAJCWlmIChhcmNf YyA+IGFyY19jX21heCkKIAkJCWFyY19jID0gYXJjX2NfbWF4OwpAQCAtMjcxMywyMCArMjk5NCw2 IEBAIGFyY19ldmljdF9uZWVkZWQoYXJjX2J1Zl9jb250ZW50c190IHR5cGUpCiAJaWYgKHR5cGUg PT0gQVJDX0JVRkNfTUVUQURBVEEgJiYgYXJjX21ldGFfdXNlZCA+PSBhcmNfbWV0YV9saW1pdCkK IAkJcmV0dXJuICgxKTsKIAotI2lmZGVmIHN1bgotI2lmZGVmIF9LRVJORUwKLQkvKgotCSAqIElm IHppbyBkYXRhIHBhZ2VzIGFyZSBiZWluZyBhbGxvY2F0ZWQgb3V0IG9mIGEgc2VwYXJhdGUgaGVh cCBzZWdtZW50LAotCSAqIHRoZW4gZW5mb3JjZSB0aGF0IHRoZSBzaXplIG9mIGF2YWlsYWJsZSB2 bWVtIGZvciB0aGlzIGFyZWEgcmVtYWlucwotCSAqIGFib3ZlIGFib3V0IDEvMzJuZCBmcmVlLgot CSAqLwotCWlmICh0eXBlID09IEFSQ19CVUZDX0RBVEEgJiYgemlvX2FyZW5hICE9IE5VTEwgJiYK LQkgICAgdm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9GUkVFKSA8Ci0JICAgICh2bWVtX3NpemUo emlvX2FyZW5hLCBWTUVNX0FMTE9DKSA+PiA1KSkKLQkJcmV0dXJuICgxKTsKLSNlbmRpZgotI2Vu ZGlmCS8qIHN1biAqLwotCiAJaWYgKGFyY19yZWNsYWltX25lZWRlZCgpKQogCQlyZXR1cm4gKDEp OwogCkBAIC0yNzYzLDYgKzMwMzAsOSBAQCBhcmNfZ2V0X2RhdGFfYnVmKGFyY19idWZfdCAqYnVm KQogCXVpbnQ2NF90CQlzaXplID0gYnVmLT5iX2hkci0+Yl9zaXplOwogCWFyY19idWZfY29udGVu dHNfdAl0eXBlID0gYnVmLT5iX2hkci0+Yl90eXBlOwogCisJaWYgKGFyY19jYWNoZV9yZWNsYWlt X25lZWRlZChzaXplKSkKKwkJKHZvaWQpIGFyY19jYWNoZV9yZWNsYWltKHNpemUsIEFSQ19DQUNI RV9SRUNMQUlNX05PVyk7CisKIAlhcmNfYWRhcHQoc2l6ZSwgc3RhdGUpOwogCiAJLyoKQEAgLTM4 ODUsMjAgKzQxNTUsMTYgQEAgc3RhdGljIGludAogYXJjX21lbW9yeV90aHJvdHRsZSh1aW50NjRf dCByZXNlcnZlLCB1aW50NjRfdCB0eGcpCiB7CiAjaWZkZWYgX0tFUk5FTAotCXVpbnQ2NF90IGF2 YWlsYWJsZV9tZW1vcnkgPQotCSAgICBwdG9hKCh1aW50bWF4X3QpY250LnZfZnJlZV9jb3VudCAr IGNudC52X2NhY2hlX2NvdW50KTsKKwl1aW50NjRfdCBhdmFpbGFibGVfbWVtb3J5ID0gcHRvYihm cmVlbWVtKTsKIAlzdGF0aWMgdWludDY0X3QgcGFnZV9sb2FkID0gMDsKIAlzdGF0aWMgdWludDY0 X3QgbGFzdF90eGcgPSAwOwogCi0jaWZkZWYgc3VuCi0jaWYgZGVmaW5lZChfX2kzODYpCisjaWYg ZGVmaW5lZChfX2kzODYpIHx8ICFkZWZpbmVkKFVNQV9NRF9TTUFMTF9BTExPQykKIAlhdmFpbGFi bGVfbWVtb3J5ID0KLQkgICAgTUlOKGF2YWlsYWJsZV9tZW1vcnksIHZtZW1fc2l6ZShoZWFwX2Fy ZW5hLCBWTUVNX0ZSRUUpKTsKKwkgICAgTUlOKGF2YWlsYWJsZV9tZW1vcnksIHB0b2Iodm1lbV9z aXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkpKTsKICNlbmRpZgotI2VuZGlmCS8qIHN1biAqLwog Ci0JaWYgKGNudC52X2ZyZWVfY291bnQgKyBjbnQudl9jYWNoZV9jb3VudCA+Ci0JICAgICh1aW50 NjRfdClwaHlzbWVtICogYXJjX2xvdHNmcmVlX3BlcmNlbnQgLyAxMDApCisJaWYgKGZyZWVtZW0g PiAodWludDY0X3QpcGh5c21lbSAqIGFyY19sb3RzZnJlZV9wZXJjZW50IC8gMTAwKQogCQlyZXR1 cm4gKDApOwogCiAJaWYgKHR4ZyA+IGxhc3RfdHhnKSB7CkBAIC0zOTExLDcgKzQxNzcsNyBAQCBh cmNfbWVtb3J5X3Rocm90dGxlKHVpbnQ2NF90IHJlc2VydmUsIHVpbnQ2NF90IHR4ZwogCSAqIGNv bnRpbnVlIHRvIGxldCBwYWdlIHdyaXRlcyBvY2N1ciBhcyBxdWlja2x5IGFzIHBvc3NpYmxlLgog CSAqLwogCWlmIChjdXJwcm9jID09IHBhZ2Vwcm9jKSB7Ci0JCWlmIChwYWdlX2xvYWQgPiBhdmFp bGFibGVfbWVtb3J5IC8gNCkKKwkJaWYgKHBhZ2VfbG9hZCA+IE1BWChwdG9iKG1pbmZyZWUpLCBh dmFpbGFibGVfbWVtb3J5KSAvIDQpCiAJCQlyZXR1cm4gKFNFVF9FUlJPUihFUkVTVEFSVCkpOwog CQkvKiBOb3RlOiByZXNlcnZlIGlzIGluZmxhdGVkLCBzbyB3ZSBkZWZsYXRlICovCiAJCXBhZ2Vf bG9hZCArPSByZXNlcnZlIC8gODsKQEAgLTM5MzksOCArNDIwNSwxMCBAQCBhcmNfdGVtcHJlc2Vy dmVfc3BhY2UodWludDY0X3QgcmVzZXJ2ZSwgdWludDY0X3QgdAogCWludCBlcnJvcjsKIAl1aW50 NjRfdCBhbm9uX3NpemU7CiAKLQlpZiAocmVzZXJ2ZSA+IGFyY19jLzQgJiYgIWFyY19ub19ncm93 KQorCWlmIChyZXNlcnZlID4gYXJjX2MvNCAmJiAhYXJjX25vX2dyb3cpIHsKIAkJYXJjX2MgPSBN SU4oYXJjX2NfbWF4LCByZXNlcnZlICogNCk7CisJCURUUkFDRV9QUk9CRTEoYXJjX19zZXRfcmVz ZXJ2ZSwgdWludDY0X3QsIGFyY19jKTsKKwl9CiAJaWYgKHJlc2VydmUgPiBhcmNfYykKIAkJcmV0 dXJuIChTRVRfRVJST1IoRU5PTUVNKSk7CiAKQEAgLTM5OTQsNiArNDI2Miw3IEBAIGFyY19sb3dt ZW0odm9pZCAqYXJnIF9fdW51c2VkLCBpbnQgaG93dG8gX191bnVzZWQpCiAJbXV0ZXhfZW50ZXIo JmFyY19sb3dtZW1fbG9jayk7CiAJbXV0ZXhfZW50ZXIoJmFyY19yZWNsYWltX3Rocl9sb2NrKTsK IAluZWVkZnJlZSA9IDE7CisJRFRSQUNFX1BST0JFKGFyY19fbmVlZGZyZWUpOwogCWN2X3NpZ25h bCgmYXJjX3JlY2xhaW1fdGhyX2N2KTsKIAogCS8qCkluZGV4OiBzeXMvY2RkbC9jb250cmliL29w ZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3JhbmdlX3RyZWUuYwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBz eXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3JhbmdlX3RyZWUu YwkocmV2aXNpb24gMjcyMDA1KQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMv Y29tbW9uL2ZzL3pmcy9yYW5nZV90cmVlLmMJKHdvcmtpbmcgY29weSkKQEAgLTMzLDcgKzMzLDcg QEAKICNpbmNsdWRlIDxzeXMvemlvLmg+CiAjaW5jbHVkZSA8c3lzL3JhbmdlX3RyZWUuaD4KIAot c3RhdGljIGttZW1fY2FjaGVfdCAqcmFuZ2Vfc2VnX2NhY2hlOwora21lbV9jYWNoZV90ICpyYW5n ZV9zZWdfY2FjaGU7CiAKIHZvaWQKIHJhbmdlX3RyZWVfaW5pdCh2b2lkKQpJbmRleDogc3lzL2Nk ZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy92ZGV2X3F1ZXVlLmMKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pm cy92ZGV2X3F1ZXVlLmMJKHJldmlzaW9uIDI3MjAwNSkKKysrIHN5cy9jZGRsL2NvbnRyaWIvb3Bl bnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvdmRldl9xdWV1ZS5jCSh3b3JraW5nIGNvcHkpCkBA IC0zMTIsNiArMzEyLDggQEAgdmRldl9xdWV1ZV9pb19hZGQodmRldl9xdWV1ZV90ICp2cSwgemlv X3QgKnppbykKIAlBU1NFUlQoTVVURVhfSEVMRCgmdnEtPnZxX2xvY2spKTsKIAlBU1NFUlQzVSh6 aW8tPmlvX3ByaW9yaXR5LCA8LCBaSU9fUFJJT1JJVFlfTlVNX1FVRVVFQUJMRSk7CiAJYXZsX2Fk ZCgmdnEtPnZxX2NsYXNzW3ppby0+aW9fcHJpb3JpdHldLnZxY19xdWV1ZWRfdHJlZSwgemlvKTsK KwlEVFJBQ0VfUFJPQkUzKHZkZXZfcXVldWUsIHZkZXZfcXVldWVfdCAqLCB2cSwgemlvX3QgKiwg emlvLCB1aW50NjRfdCwKKwkgICAgYXZsX251bW5vZGVzKCZ2cS0+dnFfY2xhc3NbemlvLT5pb19w cmlvcml0eV0udnFjX3F1ZXVlZF90cmVlKSk7CiAKICNpZmRlZiBpbGx1bW9zCiAJbXV0ZXhfZW50 ZXIoJnNwYS0+c3BhX2lva3N0YXRfbG9jayk7CkluZGV4OiBzeXMvdm0vdW1hLmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gc3lzL3ZtL3VtYS5oCShyZXZpc2lvbiAyNzIwMDUpCisrKyBzeXMvdm0vdW1hLmgJKHdv cmtpbmcgY29weSkKQEAgLTYzNiw2ICs2MzYsMTcgQEAgaW50IHVtYV96b25lX2V4aGF1c3RlZCh1 bWFfem9uZV90IHpvbmUpOwogaW50IHVtYV96b25lX2V4aGF1c3RlZF9ub2xvY2sodW1hX3pvbmVf dCB6b25lKTsKIAogLyoKKyAqIFVzZWQgdG8gZGV0ZXJtaW5lIHRoZSBhbW91bnQgb2YgbWVtb3J5 IGNvbnN1bWVkIGJ5IGEgem9uZSdzIGZyZWUgc3BhY2UuCisgKgorICogQXJndW1lbnRzOgorICoJ em9uZQlUaGUgem9uZSB0byBkZXRlcm1pbmUgdGhlIGZyZWUgc3BhY2Ugb2YuCisgKgorICogUmV0 dXJuczoKKyAqCXVpbnQ2NF90IFRoZSBhbW91bnQgb2YgbWVtb3J5IGNvbnN1bWVkIGJ5IHRoZSB6 b25lJ3MgZnJlZSBzcGFjZS4KKyAqLwordWludDY0X3QgdW1hX3pvbmVfZnJlZV9zaXplKHVtYV96 b25lX3Qgem9uZSk7CisKKy8qCiAgKiBDb21tb24gVU1BX1pPTkVfUENQVSB6b25lcy4KICAqLwog ZXh0ZXJuIHVtYV96b25lX3QgcGNwdV96b25lXzY0OwpJbmRleDogc3lzL3ZtL3VtYV9jb3JlLmMK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gc3lzL3ZtL3VtYV9jb3JlLmMJKHJldmlzaW9uIDI3MjAwNSkKKysrIHN5 cy92bS91bWFfY29yZS5jCSh3b3JraW5nIGNvcHkpCkBAIC0zMzEyLDYgKzMzMTIsMzMgQEAgdW1h X3ByaW50X3pvbmUodW1hX3pvbmVfdCB6b25lKQogCX0KIH0KIAordWludDY0X3QKK3VtYV96b25l X2ZyZWVfc2l6ZSh1bWFfem9uZV90IHpvbmUpCit7CisJaW50IGNwdTsKKwl1aW50NjRfdCBjYWNo ZWZyZWU7CisJdW1hX2J1Y2tldF90IGJ1Y2tldDsKKwl1bWFfY2FjaGVfdCBjYWNoZTsKKworCWNh Y2hlZnJlZSA9IDA7CisKKwlaT05FX0xPQ0soem9uZSk7CisJTElTVF9GT1JFQUNIKGJ1Y2tldCwg JnpvbmUtPnV6X2J1Y2tldHMsIHViX2xpbmspCisJCWNhY2hlZnJlZSArPSAodWludDY0X3QpYnVj a2V0LT51Yl9jbnQ7CisKKwlDUFVfRk9SRUFDSChjcHUpIHsKKwkJY2FjaGUgPSAmem9uZS0+dXpf Y3B1W2NwdV07CisJCWlmIChjYWNoZS0+dWNfYWxsb2NidWNrZXQgIT0gTlVMTCkKKwkJCWNhY2hl ZnJlZSArPSAodWludDY0X3QpY2FjaGUtPnVjX2FsbG9jYnVja2V0LT51Yl9jbnQ7CisJCWlmIChj YWNoZS0+dWNfZnJlZWJ1Y2tldCAhPSBOVUxMKQorCQkJY2FjaGVmcmVlICs9ICh1aW50NjRfdClj YWNoZS0+dWNfZnJlZWJ1Y2tldC0+dWJfY250OworCX0gCisJY2FjaGVmcmVlICo9IHpvbmUtPnV6 X3NpemU7CisJWk9ORV9VTkxPQ0soem9uZSk7CisKKwlyZXR1cm4gKGNhY2hlZnJlZSk7Cit9CisK ICNpZmRlZiBEREIKIC8qCiAgKiBHZW5lcmF0ZSBzdGF0aXN0aWNzIGFjcm9zcyBib3RoIHRoZSB6 b25lIGFuZCBpdHMgcGVyLWNwdSBjYWNoZSdzLiAgUmV0dXJuCkluZGV4OiBzeXMvdm0vdm1fcGFn ZW91dC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIHN5cy92bS92bV9wYWdlb3V0LmMJKHJldmlzaW9uIDI3MjAw NSkKKysrIHN5cy92bS92bV9wYWdlb3V0LmMJKHdvcmtpbmcgY29weSkKQEAgLTc2LDYgKzc2LDcg QEAKIF9fRkJTRElEKCIkRnJlZUJTRCQiKTsKIAogI2luY2x1ZGUgIm9wdF92bS5oIgorI2luY2x1 ZGUgIm9wdF9rZHRyYWNlLmgiCiAjaW5jbHVkZSA8c3lzL3BhcmFtLmg+CiAjaW5jbHVkZSA8c3lz L3N5c3RtLmg+CiAjaW5jbHVkZSA8c3lzL2tlcm5lbC5oPgpAQCAtODksNiArOTAsNyBAQCBfX0ZC U0RJRCgiJEZyZWVCU0QkIik7CiAjaW5jbHVkZSA8c3lzL3JhY2N0Lmg+CiAjaW5jbHVkZSA8c3lz L3Jlc291cmNldmFyLmg+CiAjaW5jbHVkZSA8c3lzL3NjaGVkLmg+CisjaW5jbHVkZSA8c3lzL3Nk dC5oPgogI2luY2x1ZGUgPHN5cy9zaWduYWx2YXIuaD4KICNpbmNsdWRlIDxzeXMvc21wLmg+CiAj aW5jbHVkZSA8c3lzL3Zub2RlLmg+CkBAIC0xMTUsMTAgKzExNywxNCBAQCBfX0ZCU0RJRCgiJEZy ZWVCU0QkIik7CiAKIC8qIHRoZSBrZXJuZWwgcHJvY2VzcyAidm1fcGFnZW91dCIqLwogc3RhdGlj IHZvaWQgdm1fcGFnZW91dCh2b2lkKTsKK3N0YXRpYyB2b2lkIHZtX3BhZ2VvdXRfaW5pdCh2b2lk KTsKIHN0YXRpYyBpbnQgdm1fcGFnZW91dF9jbGVhbih2bV9wYWdlX3QpOwogc3RhdGljIHZvaWQg dm1fcGFnZW91dF9zY2FuKHN0cnVjdCB2bV9kb21haW4gKnZtZCwgaW50IHBhc3MpOwogc3RhdGlj IHZvaWQgdm1fcGFnZW91dF9taWdodGJlX29vbShzdHJ1Y3Qgdm1fZG9tYWluICp2bWQsIGludCBw YXNzKTsKIAorU1lTSU5JVChwYWdlZGFlbW9uX2luaXQsIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJ X09SREVSX0ZJUlNULCB2bV9wYWdlb3V0X2luaXQsCisgICAgTlVMTCk7CisKIHN0cnVjdCBwcm9j ICpwYWdlcHJvYzsKIAogc3RhdGljIHN0cnVjdCBrcHJvY19kZXNjIHBhZ2Vfa3AgPSB7CkBAIC0x MjYsOSArMTMyLDEzIEBAIHN0YXRpYyBzdHJ1Y3Qga3Byb2NfZGVzYyBwYWdlX2twID0gewogCXZt X3BhZ2VvdXQsCiAJJnBhZ2Vwcm9jCiB9OwotU1lTSU5JVChwYWdlZGFlbW9uLCBTSV9TVUJfS1RI UkVBRF9QQUdFLCBTSV9PUkRFUl9GSVJTVCwga3Byb2Nfc3RhcnQsCitTWVNJTklUKHBhZ2VkYWVt b24sIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX1NFQ09ORCwga3Byb2Nfc3RhcnQsCiAg ICAgJnBhZ2Vfa3ApOwogCitTRFRfUFJPVklERVJfREVGSU5FKHZtKTsKK1NEVF9QUk9CRV9ERUZJ TkUodm0sICwgLCB2bV9fbG93bWVtX2NhY2hlKTsKK1NEVF9QUk9CRV9ERUZJTkUodm0sICwgLCB2 bV9fbG93bWVtX3NjYW4pOworCiAjaWYgIWRlZmluZWQoTk9fU1dBUFBJTkcpCiAvKiB0aGUga2Vy bmVsIHByb2Nlc3MgInZtX2RhZW1vbiIqLwogc3RhdGljIHZvaWQgdm1fZGFlbW9uKHZvaWQpOwpA QCAtNjYzLDYgKzY3Myw3IEBAIHZtX3BhZ2VvdXRfZ3Jvd19jYWNoZShpbnQgdHJpZXMsIHZtX3Bh ZGRyX3QgbG93LCB2CiAJCSAqIG1heSBhY3F1aXJlIGxvY2tzIGFuZC9vciBzbGVlcCwgc28gdGhl eSBjYW4gb25seSBiZSBpbnZva2VkCiAJCSAqIHdoZW4gInRyaWVzIiBpcyBncmVhdGVyIHRoYW4g emVyby4KIAkJICovCisJCVNEVF9QUk9CRTAodm0sICwgLCB2bV9fbG93bWVtX2NhY2hlKTsKIAkJ RVZFTlRIQU5ETEVSX0lOVk9LRSh2bV9sb3dtZW0sIDApOwogCiAJCS8qCkBAIC05MjEsMTAgKzkz MiwxMSBAQCB2bV9wYWdlb3V0X3NjYW4oc3RydWN0IHZtX2RvbWFpbiAqdm1kLCBpbnQgcGFzcykK IAkgKiBzb21lLiAgV2UgcmF0ZSBsaW1pdCB0byBhdm9pZCB0aHJhc2hpbmcuCiAJICovCiAJaWYg KHZtZCA9PSAmdm1fZG9tWzBdICYmIHBhc3MgPiAwICYmCi0JICAgIGxvd21lbV90aWNrcyArIChs b3dtZW1fcGVyaW9kICogaHopIDwgdGlja3MpIHsKKwkgICAgKHRpY2tzIC0gbG93bWVtX3RpY2tz KSAvIGh6ID49IGxvd21lbV9wZXJpb2QpIHsKIAkJLyoKIAkJICogRGVjcmVhc2UgcmVnaXN0ZXJl ZCBjYWNoZSBzaXplcy4KIAkJICovCisJCVNEVF9QUk9CRTAodm0sICwgLCB2bV9fbG93bWVtX3Nj YW4pOwogCQlFVkVOVEhBTkRMRVJfSU5WT0tFKHZtX2xvd21lbSwgMCk7CiAJCS8qCiAJCSAqIFdl IGRvIHRoaXMgZXhwbGljaXRseSBhZnRlciB0aGUgY2FjaGVzIGhhdmUgYmVlbgpAQCAtMTY1MCwx NSArMTY2MiwxMSBAQCB2bV9wYWdlb3V0X3dvcmtlcih2b2lkICphcmcpCiB9CiAKIC8qCi0gKgl2 bV9wYWdlb3V0IGlzIHRoZSBoaWdoIGxldmVsIHBhZ2VvdXQgZGFlbW9uLgorICoJdm1fcGFnZW91 dF9pbml0IGluaXRpYWxpc2VzIGJhc2ljIHBhZ2VvdXQgZGFlbW9uIHNldHRpbmdzLgogICovCiBz dGF0aWMgdm9pZAotdm1fcGFnZW91dCh2b2lkKQordm1fcGFnZW91dF9pbml0KHZvaWQpCiB7Ci0j aWYgTUFYTUVNRE9NID4gMQotCWludCBlcnJvciwgaTsKLSNlbmRpZgotCiAJLyoKIAkgKiBJbml0 aWFsaXplIHNvbWUgcGFnaW5nIHBhcmFtZXRlcnMuCiAJICovCkBAIC0xNzA0LDcgKzE3MTIsMTgg QEAgc3RhdGljIHZvaWQKIAkvKiBYWFggZG9lcyBub3QgcmVhbGx5IGJlbG9uZyBoZXJlICovCiAJ aWYgKHZtX3BhZ2VfbWF4X3dpcmVkID09IDApCiAJCXZtX3BhZ2VfbWF4X3dpcmVkID0gY250LnZf ZnJlZV9jb3VudCAvIDM7Cit9CiAKKy8qCisgKiAgICAgdm1fcGFnZW91dCBpcyB0aGUgaGlnaCBs ZXZlbCBwYWdlb3V0IGRhZW1vbi4KKyAqLworc3RhdGljIHZvaWQKK3ZtX3BhZ2VvdXQodm9pZCkK K3sKKyNpZiBNQVhNRU1ET00gPiAxCisJaW50IGVycm9yLCBpOworI2VuZGlmCisKIAlzd2FwX3Bh Z2VyX3N3YXBfaW5pdCgpOwogI2lmIE1BWE1FTURPTSA+IDEKIAlmb3IgKGkgPSAxOyBpIDwgdm1f bmRvbWFpbnM7IGkrKykgewo= 147738 2014-09-27 23:50:14 +0000 2014-09-30 02:36:57 +0000 ARC reclaim refactor + uma clear down (against stable/10) arc_cache_reclaim_uma_stable10.patch text/plain 26851 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MjAwNSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMzQsNiArMzQs NyBAQCBfX0ZCU0RJRCgiJEZyZWVCU0QkIik7CiAjaW5jbHVkZSA8c3lzL2ttZW0uaD4KICNpbmNs dWRlIDxzeXMvZGVidWcuaD4KICNpbmNsdWRlIDxzeXMvbXV0ZXguaD4KKyNpbmNsdWRlIDxzeXMv c2R0Lmg+CiAKICNpbmNsdWRlIDx2bS92bV9wYWdlLmg+CiAjaW5jbHVkZSA8dm0vdm1fb2JqZWN0 Lmg+CkBAIC0xMzMsMTMgKzEzNCw2IEBAIGttZW1fc2l6ZSh2b2lkKQogCXJldHVybiAoa21lbV9z aXplX3ZhbCk7CiB9CiAKLXVpbnQ2NF90Ci1rbWVtX3VzZWQodm9pZCkKLXsKLQotCXJldHVybiAo dm1lbV9zaXplKGttZW1fYXJlbmEsIFZNRU1fQUxMT0MpKTsKLX0KLQogc3RhdGljIGludAoga21l bV9zdGRfY29uc3RydWN0b3Iodm9pZCAqbWVtLCBpbnQgc2l6ZSBfX3VudXNlZCwgdm9pZCAqcHJp dmF0ZSwgaW50IGZsYWdzKQogewpAQCAtMjI4LDEyICsyMjIsNDUgQEAga21lbV9jYWNoZV9yZWFw X25vdyhrbWVtX2NhY2hlX3QgKmNhY2hlKQogfQogCiB2b2lkCitrbWVtX2NhY2hlX3JlYXAoa21l bV9jYWNoZV90ICpjYWNoZSwgdWludDY0X3QgbWF4ZnJlZSkKK3sKKworCWlmIChjYWNoZS0+a2Nf em9uZSAhPSBOVUxMICYmCisJICAgIHVtYV96b25lX2ZyZWVfc2l6ZShjYWNoZS0+a2Nfem9uZSkg PiBtYXhmcmVlKQorCQl6b25lX2RyYWluKGNhY2hlLT5rY196b25lKTsKK30KKwordm9pZAoga21l bV9yZWFwKHZvaWQpCiB7CiAJdW1hX3JlY2xhaW0oKTsKIH0KKwordWludDY0X3QKK2ttZW1fY2Fj aGVfZnJlZV9zaXplKGttZW1fY2FjaGVfdCAqY2FjaGUpCit7CisJdWludDY0X3QgY2FjaGVmcmVl OworCisJY2FjaGVmcmVlID0gKGNhY2hlLT5rY196b25lID09IE5VTEwpID8gMCA6CisJICAgIHVt YV96b25lX2ZyZWVfc2l6ZShjYWNoZS0+a2Nfem9uZSk7CisKKwkvKgorCSAqIE1hbnVhbCBwcm9i ZSBhcyB0aGUgcmV0dXJuIGZidCBwcm9iZSBuZXZlciBmaXJlcyBkdWUgdG8KKwkgKiBjb21waWxl ciB0YWxsIGNhbGwgb3B0aW1pc2F0aW9uLgorCSAqLworCURUUkFDRV9QUk9CRTIoa21lbV9jYWNo ZV9mcmVlX3NpemUsIGNoYXIgKiwgY2FjaGUtPmtjX25hbWUsIHVpbnQ2NF90LAorCSAgICBjYWNo ZWZyZWUpOworCisJcmV0dXJuIChjYWNoZWZyZWUpOworfQorCiAjZWxzZQogdm9pZAora21lbV9j YWNoZV9yZWFwKGttZW1fY2FjaGVfdCAqY2FjaGUsIHVpbnQ2NF90IG1heGZyZWUpCit7Cit9CisK K3ZvaWQKIGttZW1fY2FjaGVfcmVhcF9ub3coa21lbV9jYWNoZV90ICpjYWNoZSBfX3VudXNlZCkK IHsKIH0KQEAgLTI0Miw2ICsyNjksMTEgQEAgdm9pZAoga21lbV9yZWFwKHZvaWQpCiB7CiB9CisK K3VpbnQ2NF90CitrbWVtX2NhY2hlX2ZyZWVfc2l6ZShrbWVtX2NhY2hlX3QgKmNhY2hlKQorewor fQogI2VuZGlmCiAKIGludApJbmRleDogc3lzL2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9r bWVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVt LmgJKHJldmlzaW9uIDI3MjAwNSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMv a21lbS5oCSh3b3JraW5nIGNvcHkpCkBAIC00NCw3ICs0NCw3IEBAIE1BTExPQ19ERUNMQVJFKE1f U09MQVJJUyk7CiAjZGVmaW5lCVBPSU5URVJfSU5WQUxJREFURShwcCkJKCoocHApID0gKHZvaWQg KikoKHVpbnRwdHJfdCkoKihwcCkpIHwgMHgxKSkKIAogI2RlZmluZQlLTV9TTEVFUAkJTV9XQUlU T0sKLSNkZWZpbmUJS01fUFVTSFBBR0UJCU1fV0FJVE9LCisjZGVmaW5lCUtNX1BVU0hQQUdFCQlN X1dBSVRPS3xNX1VTRV9SRVNFUlZFCiAjZGVmaW5lCUtNX05PU0xFRVAJCU1fTk9XQUlUCiAjZGVm aW5lCUtNX05PREVCVUcJCU1fTk9EVU1QCiAjZGVmaW5lCUtNX05PUk1BTFBSSQkJMApAQCAtNjYs NyArNjYsNiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZvaWQgKnpmc19rbWVtX2Fs bG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19rbWVtX2ZyZWUodm9pZCAq YnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9pZCk7Ci11aW50NjRfdCBr bWVtX3VzZWQodm9pZCk7CiBrbWVtX2NhY2hlX3QgKmttZW1fY2FjaGVfY3JlYXRlKGNoYXIgKm5h bWUsIHNpemVfdCBidWZzaXplLCBzaXplX3QgYWxpZ24sCiAgICAgaW50ICgqY29uc3RydWN0b3Ip KHZvaWQgKiwgdm9pZCAqLCBpbnQpLCB2b2lkICgqZGVzdHJ1Y3Rvcikodm9pZCAqLCB2b2lkICop LAogICAgIHZvaWQgKCpyZWNsYWltKSh2b2lkICopIF9fdW51c2VkLCB2b2lkICpwcml2YXRlLCB2 bWVtX3QgKnZtcCwgaW50IGNmbGFncyk7CkBAIC03NCwxMCArNzMsMTUgQEAgdm9pZCBrbWVtX2Nh Y2hlX2Rlc3Ryb3koa21lbV9jYWNoZV90ICpjYWNoZSk7CiB2b2lkICprbWVtX2NhY2hlX2FsbG9j KGttZW1fY2FjaGVfdCAqY2FjaGUsIGludCBmbGFncyk7CiB2b2lkIGttZW1fY2FjaGVfZnJlZShr bWVtX2NhY2hlX3QgKmNhY2hlLCB2b2lkICpidWYpOwogdm9pZCBrbWVtX2NhY2hlX3JlYXBfbm93 KGttZW1fY2FjaGVfdCAqY2FjaGUpOwordm9pZCBrbWVtX2NhY2hlX3JlYXAoa21lbV9jYWNoZV90 ICpjYWNoZSwgdWludDY0X3QgbWF4ZnJlZSk7CiB2b2lkIGttZW1fcmVhcCh2b2lkKTsKK3VpbnQ2 NF90IGttZW1fY2FjaGVfZnJlZV9zaXplKGttZW1fY2FjaGVfdCAqY2FjaGUpOwogaW50IGttZW1f ZGVidWdnaW5nKHZvaWQpOwogdm9pZCAqY2FsbG9jKHNpemVfdCBuLCBzaXplX3Qgcyk7CiAKKyNk ZWZpbmUJZnJlZW1lbQkJCQkoY250LnZfZnJlZV9jb3VudCArIGNudC52X2NhY2hlX2NvdW50KQor I2RlZmluZQltaW5mcmVlCQkJCWNudC52X2ZyZWVfbWluCisjZGVmaW5lCWhlYXBfYXJlbmEJCQlr bWVtX2FyZW5hCiAjZGVmaW5lCWttZW1fYWxsb2Moc2l6ZSwga21mbGFncykJemZzX2ttZW1fYWxs b2MoKHNpemUpLCAoa21mbGFncykpCiAjZGVmaW5lCWttZW1femFsbG9jKHNpemUsIGttZmxhZ3Mp CXpmc19rbWVtX2FsbG9jKChzaXplKSwgKGttZmxhZ3MpIHwgTV9aRVJPKQogI2RlZmluZQlrbWVt X2ZyZWUoYnVmLCBzaXplKQkJemZzX2ttZW1fZnJlZSgoYnVmKSwgKHNpemUpKQpJbmRleDogc3lz L2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9wYXJhbS5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9j ZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMvcGFyYW0uaAkocmV2aXNpb24gMjcyMDA1KQorKysg c3lzL2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9wYXJhbS5oCSh3b3JraW5nIGNvcHkpCkBA IC0zNiw2ICszNiw3IEBACiAKICNpZmRlZiBfS0VSTkVMCiAjZGVmaW5lCXB0b2IoeCkJCSgodWlu dDY0X3QpKHgpIDw8IFBBR0VfU0hJRlQpCisjZGVmaW5lCWJ0b3AoeCkJCSgodWludDY0X3QpKHgp ID4+IFBBR0VfU0hJRlQpCiAjZW5kaWYKIAogI2VuZGlmCkluZGV4OiBzeXMvY2RkbC9jb250cmli L29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9j ZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvYXJjLmMJKHJldmlzaW9u IDI3MjAwNSkKKysrIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96 ZnMvYXJjLmMJKHdvcmtpbmcgY29weSkKQEAgLTEzOCw2ICsxMzgsNyBAQAogI2luY2x1ZGUgPHN5 cy9zZHQuaD4KIAogI2luY2x1ZGUgPHZtL3ZtX3BhZ2VvdXQuaD4KKyNpbmNsdWRlIDxtYWNoaW5l L3ZtcGFyYW0uaD4KIAogI2lmZGVmIGlsbHVtb3MKICNpZm5kZWYgX0tFUk5FTApAQCAtMTU5LDYg KzE2MCwxNSBAQCB0eXBlZGVmIGVudW0gYXJjX3JlY2xhaW1fc3RyYXRlZ3kgewogCUFSQ19SRUNM QUlNX0NPTlMJCS8qIENvbnNlcnZhdGl2ZSByZWNsYWltIHN0cmF0ZWd5ICovCiB9IGFyY19yZWNs YWltX3N0cmF0ZWd5X3Q7CiAKK3R5cGVkZWYgZW51bSBhcmNfY2FjaGVfcmVjbGFpbV9zdHJhZ2Vn eSB7CisJQVJDX0NBQ0hFX1JFQ0xBSU1fTk9XLAkJLyogSW1tZWRpYXRlIHJlY2xhaW0gc3RyYXRl Z3kgKi8KKwlBUkNfQ0FDSEVfUkVDTEFJTV9TSVpFLAkJLyogRnJlZSBzaXplIHJlY2xhaW0gc3Ry YXRlZ3kgKi8KKwlBUkNfQ0FDSEVfUkVDTEFJTV9GT1JDRSwJLyogRm9yY2VkIGltbWVkaWF0ZSBy ZWNsYWltIHN0cmF0ZWd5ICovCit9IGFyY19jYWNoZV9yZWNsYWltX3N0cmF0ZWd5X3Q7CisKKy8q IFdoZW4gdGhlIGxhc3QgY2FjaGUgcmVjbGFpbSB3YXMgcHJvY2Vzc2VkLiAqLworc3RhdGljIGNs b2NrX3QgY2FjaGVfcmVjbGFpbV9sYXN0ID0gMDsKKwogLyoKICAqIFRoZSBudW1iZXIgb2YgaXRl cmF0aW9ucyB0aHJvdWdoIGFyY19ldmljdF8qKCkgYmVmb3JlIHdlCiAgKiBkcm9wICYgcmVhY3F1 aXJlIHRoZSBsb2NrLgpAQCAtMTkzLDkgKzIwMyw2IEBAIGV4dGVybiBpbnQgemZzX3ByZWZldGNo X2Rpc2FibGU7CiAgKi8KIHN0YXRpYyBib29sZWFuX3QgYXJjX3dhcm07CiAKLS8qCi0gKiBUaGVz ZSB0dW5hYmxlcyBhcmUgZm9yIHBlcmZvcm1hbmNlIGFuYWx5c2lzLgotICovCiB1aW50NjRfdCB6 ZnNfYXJjX21heDsKIHVpbnQ2NF90IHpmc19hcmNfbWluOwogdWludDY0X3QgemZzX2FyY19tZXRh X2xpbWl0ID0gMDsKQEAgLTIwNCw3ICsyMTEsMjcgQEAgaW50IHpmc19hcmNfc2hyaW5rX3NoaWZ0 ID0gMDsKIGludCB6ZnNfYXJjX3BfbWluX3NoaWZ0ID0gMDsKIGludCB6ZnNfZGlzYWJsZV9kdXBf ZXZpY3Rpb24gPSAwOwogdWludDY0X3QgemZzX2FyY19hdmVyYWdlX2Jsb2Nrc2l6ZSA9IDggKiAx MDI0OyAvKiA4S0IgKi8KK3VfaW50IHpmc19hcmNfZnJlZV90YXJnZXQgPSAwOwordV9pbnQgemZz X2FyY19jYWNoZV90YXJnZXQgPSAwOworaW50IHpmc19hcmNfY2FjaGVfcGVyaW9kID0gMTA7Citp bnQgemZzX2FyY19jYWNoZV9wYXJ0aWFsID0gMDsKK2ludCB6ZnNfYXJjX2NhY2hlX2ZyZWVfcGVy aW9kID0gMzAwOwordWludDY0X3QgemZzX2FyY19jYWNoZV9mcmVlX21heCA9ICgxIDw8MjQpOyAv KiAxNk1CICovCiAKKyNpZmRlZiBfS0VSTkVMCitzdGF0aWMgaW50IHN5c2N0bF92ZnNfemZzX2Fy Y19mcmVlX3RhcmdldChTWVNDVExfSEFORExFUl9BUkdTKTsKK3N0YXRpYyBpbnQgc3lzY3RsX3Zm c196ZnNfYXJjX2NhY2hlX3RhcmdldChTWVNDVExfSEFORExFUl9BUkdTKTsKKworc3RhdGljIHZv aWQKK2FyY190YXJnZXRfaW5pdCh2b2lkICp1bnVzZWQgX191bnVzZWQpCit7CisKKwl6ZnNfYXJj X2ZyZWVfdGFyZ2V0ID0gdm1fcGFnZW91dF93YWtldXBfdGhyZXNoOworCXpmc19hcmNfY2FjaGVf dGFyZ2V0ID0gKHZtX3BhZ2VvdXRfd2FrZXVwX3RocmVzaCAvIDIpICogMzsKK30KK1NZU0lOSVQo YXJjX3RhcmdldF9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9BTlksCisgICAg YXJjX3RhcmdldF9pbml0LCBOVUxMKTsKKwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19tYXgi LCAmemZzX2FyY19tYXgpOwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19taW4iLCAmemZzX2Fy Y19taW4pOwogVFVOQUJMRV9RVUFEKCJ2ZnMuemZzLmFyY19tZXRhX2xpbWl0IiwgJnpmc19hcmNf bWV0YV9saW1pdCk7CkBAIC0yMTcsNyArMjQ0LDc1IEBAIFNZU0NUTF9VUVVBRChfdmZzX3pmcywg T0lEX0FVVE8sIGFyY19taW4sIENUTEZMQUdfCiBTWVNDVExfVVFVQUQoX3Zmc196ZnMsIE9JRF9B VVRPLCBhcmNfYXZlcmFnZV9ibG9ja3NpemUsIENUTEZMQUdfUkRUVU4sCiAgICAgJnpmc19hcmNf YXZlcmFnZV9ibG9ja3NpemUsIDAsCiAgICAgIkFSQyBhdmVyYWdlIGJsb2Nrc2l6ZSIpOworU1lT Q1RMX0lOVChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19jYWNoZV9yZWNsYWltX3BlcmlvZCwgQ1RM RkxBR19SV1RVTiwKKyAgICAmemZzX2FyY19jYWNoZV9wZXJpb2QsIDAsCisgICAgIk1pbiBudW1i ZXIgb2Ygc2Vjb25kcyBiZXR3ZWVuIEFSQyBjYWNoZSByZWNsYWltcyIpOworU1lTQ1RMX1VJTlQo X3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfY2FjaGVfcmVjbGFpbV9wYXJ0aWFsLCBDVExGTEFHX1JX VFVOLAorICAgICZ6ZnNfYXJjX2NhY2hlX3BhcnRpYWwsIDAsCisgICAgIkVuYWJsZSBBUkMgdG8g cGVyZm9ybSBwYXJ0aWFsIGNhY2hlIHJlY2xhaW1zIik7CitTWVNDVExfVVFVQUQoX3Zmc196ZnMs IE9JRF9BVVRPLCBhcmNfY2FjaGVfZnJlZV9tYXgsIENUTEZMQUdfUldUVU4sCisgICAgJnpmc19h cmNfY2FjaGVfZnJlZV9tYXgsIDAsCisgICAgIk1heGltdW0gZnJlZSBieXRlcyBpbiBhbiBBUkMg Y2FjaGUgem9uZSBiZWZvcmUgcmVjbGFpbSB3aWxsIGJlIHRyaWdnZXJlZCIpOworU1lTQ1RMX1VJ TlQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfY2FjaGVfZnJlZV9wZXJpb2QsIENUTEZMQUdfUldU VU4sCisgICAgJnpmc19hcmNfY2FjaGVfZnJlZV9wZXJpb2QsIDAsCisgICAgIk1pbiBudW1iZXIg b2Ygc2Vjb25kcyBiZXR3ZWVuIEFSQyBmcmVlIHNpemUgYmFzZWQgY2FjaGUgcmVjbGFpbXMiKTsK Ky8qCisgKiBXZSBkb24ndCBoYXZlIGEgdHVuYWJsZSBmb3IgdGhlc2Ugc3lzY3RscyBkdWUgdG8g dGhlaXIgZGVwZW5kZW5jeSBvbgorICogcGFnZWRhZW1vbiBpbml0aWFsaXNhdGlvbi4KKyAqLwor U1lTQ1RMX1BST0MoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfZnJlZV90YXJnZXQsCisgICAgQ1RM VFlQRV9VSU5UIHwgQ1RMRkxBR19NUFNBRkUgfCBDVExGTEFHX1JXLCAwLCBzaXplb2YodV9pbnQp LAorICAgIHN5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldCwgIklVIiwKKyAgICAiRGVzaXJl ZCBudW1iZXIgb2YgZnJlZSBwYWdlcyBiZWxvdyB3aGljaCBBUkMgdHJpZ2dlcnMgcmVjbGFpbSIp OworU1lTQ1RMX1BST0MoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfY2FjaGVfdGFyZ2V0LAorICAg IENUTFRZUEVfVUlOVCB8IENUTEZMQUdfTVBTQUZFIHwgQ1RMRkxBR19SVywgMCwgc2l6ZW9mKHVf aW50KSwKKyAgICBzeXNjdGxfdmZzX3pmc19hcmNfY2FjaGVfdGFyZ2V0LCAiSVUiLAorICAgICJE ZXNpcmVkIG51bWJlciBvZiBmcmVlIHBhZ2VzIGJlbG93IHdoaWNoIEFSQyB0cmlnZ2VycyBjYWNo ZSByZWNsYWltIik7CiAKKworc3RhdGljIGludAorc3lzY3RsX3Zmc196ZnNfYXJjX2ZyZWVfdGFy Z2V0KFNZU0NUTF9IQU5ETEVSX0FSR1MpCit7CisJdV9pbnQgdmFsOworCWludCBlcnI7CisKKwl2 YWwgPSB6ZnNfYXJjX2ZyZWVfdGFyZ2V0OworCWVyciA9IHN5c2N0bF9oYW5kbGVfaW50KG9pZHAs ICZ2YWwsIDAsIHJlcSk7CisJaWYgKGVyciAhPSAwIHx8IHJlcS0+bmV3cHRyID09IE5VTEwpCisJ CXJldHVybiAoZXJyKTsKKworCWlmICh2YWwgPCBtaW5mcmVlKQorCQlyZXR1cm4gKEVJTlZBTCk7 CisJaWYgKHZhbCA+IGNudC52X3BhZ2VfY291bnQpCisJCXJldHVybiAoRUlOVkFMKTsKKworCXpm c19hcmNfZnJlZV90YXJnZXQgPSB2YWw7CisKKwlyZXR1cm4gKDApOworfQorCitzdGF0aWMgaW50 CitzeXNjdGxfdmZzX3pmc19hcmNfY2FjaGVfdGFyZ2V0KFNZU0NUTF9IQU5ETEVSX0FSR1MpCit7 CisJdV9pbnQgdmFsOworCWludCBlcnI7CisKKwl2YWwgPSB6ZnNfYXJjX2NhY2hlX3RhcmdldDsK KwllcnIgPSBzeXNjdGxfaGFuZGxlX2ludChvaWRwLCAmdmFsLCAwLCByZXEpOworCWlmIChlcnIg IT0gMCB8fCByZXEtPm5ld3B0ciA9PSBOVUxMKQorCQlyZXR1cm4gKGVycik7CisKKwlpZiAodmFs IDwgbWluZnJlZSkKKwkJcmV0dXJuIChFSU5WQUwpOworCWlmICh2YWwgPiBjbnQudl9wYWdlX2Nv dW50KQorCQlyZXR1cm4gKEVJTlZBTCk7CisKKwl6ZnNfYXJjX2NhY2hlX3RhcmdldCA9IHZhbDsK KworCXJldHVybiAoMCk7Cit9CisjZW5kaWYKKwogLyoKICAqIE5vdGUgdGhhdCBidWZmZXJzIGNh biBiZSBpbiBvbmUgb2YgNiBzdGF0ZXM6CiAgKglBUkNfYW5vbgktIGFub255bW91cyAoZGlzY3Vz c2VkIGJlbG93KQpAQCAtNTkyLDYgKzY4NywxMyBAQCBzdGF0aWMgdm9pZCBhcmNfZXZpY3RfZ2hv c3QoYXJjX3N0YXRlX3QgKnN0YXRlLCB1aQogc3RhdGljIHZvaWQgYXJjX2J1Zl93YXRjaChhcmNf YnVmX3QgKmJ1Zik7CiAjZW5kaWYgLyogaWxsdW1vcyAqLwogCitzdGF0aWMgdWludDY0X3QgYXJj X2NhY2hlX2ZyZWUodm9pZCk7CitzdGF0aWMgYm9vbGVhbl90IGFyY19jYWNoZV9yZWNsYWltX25l ZWRlZCh1aW50NjRfdCBzaXplKTsKK3N0YXRpYyBib29sZWFuX3QgYXJjX2NhY2hlX3JlY2xhaW0o dWludDY0X3Qgc2l6ZSwKKyAgICBhcmNfY2FjaGVfcmVjbGFpbV9zdHJhdGVneV90IHN0cmF0KTsK K3N0YXRpYyBib29sZWFuX3QgYXJjX2NhY2hlX3JlY2xhaW1fc3RyYXQoa21lbV9jYWNoZV90ICpj YWNoZSwgdWludDY0X3Qgc2l6ZSwKKyAgICBhcmNfY2FjaGVfcmVjbGFpbV9zdHJhdGVneV90IHN0 cmF0KTsKKwogc3RhdGljIGJvb2xlYW5fdCBsMmFyY193cml0ZV9lbGlnaWJsZSh1aW50NjRfdCBz cGFfZ3VpZCwgYXJjX2J1Zl9oZHJfdCAqYWIpOwogCiAjZGVmaW5lCUdIT1NUX1NUQVRFKHN0YXRl KQlcCkBAIC0yNDIxLDYgKzI1MjMsNyBAQCBhcmNfZmx1c2goc3BhX3QgKnNwYSkKIHZvaWQKIGFy Y19zaHJpbmsodm9pZCkKIHsKKwogCWlmIChhcmNfYyA+IGFyY19jX21pbikgewogCQl1aW50NjRf dCB0b19mcmVlOwogCkBAIC0yNDI5LDYgKzI1MzIsOSBAQCBhcmNfc2hyaW5rKHZvaWQpCiAjZWxz ZQogCQl0b19mcmVlID0gYXJjX2MgPj4gYXJjX3Nocmlua19zaGlmdDsKICNlbmRpZgorCQlEVFJB Q0VfUFJPQkU0KGFyY19fc2hyaW5rLCB1aW50NjRfdCwgYXJjX2MsIHVpbnQ2NF90LAorCQkJYXJj X2NfbWluLCB1aW50NjRfdCwgYXJjX3AsIHVpbnQ2NF90LCB0b19mcmVlKTsKKwogCQlpZiAoYXJj X2MgPiBhcmNfY19taW4gKyB0b19mcmVlKQogCQkJYXRvbWljX2FkZF82NCgmYXJjX2MsIC10b19m cmVlKTsKIAkJZWxzZQpAQCAtMjQzOSwxMiArMjU0NSwxOSBAQCBhcmNfc2hyaW5rKHZvaWQpCiAJ CQlhcmNfYyA9IE1BWChhcmNfc2l6ZSwgYXJjX2NfbWluKTsKIAkJaWYgKGFyY19wID4gYXJjX2Mp CiAJCQlhcmNfcCA9IChhcmNfYyA+PiAxKTsKKworCQlEVFJBQ0VfUFJPQkUyKGFyY19fc2hydW5r LCB1aW50NjRfdCwgYXJjX2MsIHVpbnQ2NF90LAorCQkJYXJjX3ApOworCiAJCUFTU0VSVChhcmNf YyA+PSBhcmNfY19taW4pOwogCQlBU1NFUlQoKGludDY0X3QpYXJjX3AgPj0gMCk7CiAJfQogCi0J aWYgKGFyY19zaXplID4gYXJjX2MpCisJaWYgKGFyY19zaXplID4gYXJjX2MpIHsKKwkJRFRSQUNF X1BST0JFMihhcmNfX3Nocmlua19hZGp1c3QsIHVpbnQ2NF90LCBhcmNfc2l6ZSwKKwkJCXVpbnQ2 NF90LCBhcmNfYyk7CiAJCWFyY19hZGp1c3QoKTsKKwl9CiB9CiAKIHN0YXRpYyBpbnQgbmVlZGZy ZWUgPSAwOwpAQCAtMjQ1NCwxNiArMjU2NywyNiBAQCBhcmNfcmVjbGFpbV9uZWVkZWQodm9pZCkK IHsKIAogI2lmZGVmIF9LRVJORUwKKwlpZiAoYXJjX3NpemUgPD0gYXJjX2NfbWluKSB7CisJCURU UkFDRV9QUk9CRTIoYXJjX19yZWNsYWltX21pbiwgdWludDY0X3QsIGFyY19zaXplLAorCQkgICAg dWludDY0X3QsIGFyY19jX21pbik7CisJCXJldHVybiAoMCk7CisJfQogCi0JaWYgKG5lZWRmcmVl KQorCWlmIChuZWVkZnJlZSkgeworCQlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX25lZWRmcmVl KTsKIAkJcmV0dXJuICgxKTsKKwl9CiAKIAkvKgogCSAqIENvb3BlcmF0ZSB3aXRoIHBhZ2VkYWVt b24gd2hlbiBpdCdzIHRpbWUgZm9yIGl0IHRvIHNjYW4KIAkgKiBhbmQgcmVjbGFpbSBzb21lIHBh Z2VzLgogCSAqLwotCWlmICh2bV9wYWdpbmdfbmVlZGVkKCkpCisJaWYgKGZyZWVtZW0gPCB6ZnNf YXJjX2ZyZWVfdGFyZ2V0KSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19yZWNsYWltX2ZyZWVtZW0s IHVpbnQ2NF90LAorCQkgICAgZnJlZW1lbSwgdWludDY0X3QsIHpmc19hcmNfZnJlZV90YXJnZXQp OwogCQlyZXR1cm4gKDEpOworCX0KIAogI2lmZGVmIHN1bgogCS8qCkBAIC0yNDkxLDggKzI2MTQs MTkgQEAgYXJjX3JlY2xhaW1fbmVlZGVkKHZvaWQpCiAJaWYgKGF2YWlscm1lbSA8IHN3YXBmc19t aW5mcmVlICsgc3dhcGZzX3Jlc2VydmUgKyBleHRyYSkKIAkJcmV0dXJuICgxKTsKIAotI2lmIGRl ZmluZWQoX19pMzg2KQogCS8qCisJICogQ2hlY2sgdGhhdCB3ZSBoYXZlIGVub3VnaCBhdmFpbHJt ZW0gdGhhdCBtZW1vcnkgbG9ja2luZyAoZS5nLiwgdmlhCisJICogbWxvY2soM0MpIG9yIG1lbWNu dGwoMikpIGNhbiBzdGlsbCBzdWNjZWVkLiAgKHBhZ2VzX3BwX21heGltdW0KKwkgKiBzdG9yZXMg dGhlIG51bWJlciBvZiBwYWdlcyB0aGF0IGNhbm5vdCBiZSBsb2NrZWQ7IHdoZW4gYXZhaWxybWVt CisJICogZHJvcHMgYmVsb3cgcGFnZXNfcHBfbWF4aW11bSwgcGFnZSBsb2NraW5nIG1lY2hhbmlz bXMgc3VjaCBhcworCSAqIHBhZ2VfcHBfbG9jaygpIHdpbGwgZmFpbC4pCisJICovCisJaWYgKGF2 YWlscm1lbSA8PSBwYWdlc19wcF9tYXhpbXVtKQorCQlyZXR1cm4gKDEpOworCisjZW5kaWYJLyog c3VuICovCisjaWYgZGVmaW5lZChfX2kzODYpIHx8ICFkZWZpbmVkKFVNQV9NRF9TTUFMTF9BTExP QykKKwkvKgogCSAqIElmIHdlJ3JlIG9uIGFuIGkzODYgcGxhdGZvcm0sIGl0J3MgcG9zc2libGUg dGhhdCB3ZSdsbCBleGhhdXN0IHRoZQogCSAqIGtlcm5lbCBoZWFwIHNwYWNlIGJlZm9yZSB3ZSBl dmVyIHJ1biBvdXQgb2YgYXZhaWxhYmxlIHBoeXNpY2FsCiAJICogbWVtb3J5LiAgTW9zdCBjaGVj a3Mgb2YgdGhlIHNpemUgb2YgdGhlIGhlYXBfYXJlYSBjb21wYXJlIGFnYWluc3QKQEAgLTI1MDMs MjYgKzI2MzcsNDMgQEAgYXJjX3JlY2xhaW1fbmVlZGVkKHZvaWQpCiAJICogaGVhcCBpcyBhbGxv Y2F0ZWQuICAoT3IsIGluIHRoZSBjYWxjdWxhdGlvbiwgaWYgbGVzcyB0aGFuIDEvNHRoIGlzCiAJ ICogZnJlZSkKIAkgKi8KLQlpZiAoYnRvcCh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVF KSkgPAotCSAgICAoYnRvcCh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwgVk1FTV9B TExPQykpID4+IDIpKQorCWlmICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSA8CisJ ICAgICh2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFIHwgVk1FTV9BTExPQykgPj4gMikp IHsKKwkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fdXNlZCwgdWludDY0X3QsCisJCSAgICB2 bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSwgdWludDY0X3QsCisJCSAgICAodm1lbV9z aXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpKSA+PiAyKTsKIAkJcmV0dXJu ICgxKTsKKwl9CiAjZW5kaWYKLSNlbHNlCS8qICFzdW4gKi8KLQlpZiAoa21lbV91c2VkKCkgPiAo a21lbV9zaXplKCkgKiAzKSAvIDQpCisjaWZkZWYgc3VuCisJLyoKKwkgKiBJZiB6aW8gZGF0YSBw YWdlcyBhcmUgYmVpbmcgYWxsb2NhdGVkIG91dCBvZiBhIHNlcGFyYXRlIGhlYXAgc2VnbWVudCwK KwkgKiB0aGVuIGVuZm9yY2UgdGhhdCB0aGUgc2l6ZSBvZiBhdmFpbGFibGUgdm1lbSBmb3IgdGhp cyBhcmVuYSByZW1haW5zCisJICogYWJvdmUgYWJvdXQgMS8xNnRoIGZyZWUuCisJICoKKwkgKiBO b3RlOiBUaGUgMS8xNnRoIGFyZW5hIGZyZWUgcmVxdWlyZW1lbnQgd2FzIHB1dCBpbiBwbGFjZQor CSAqIHRvIGFnZ3Jlc3NpdmVseSBldmljdCBtZW1vcnkgZnJvbSB0aGUgYXJjIGluIG9yZGVyIHRv IGF2b2lkCisJICogbWVtb3J5IGZyYWdtZW50YXRpb24gaXNzdWVzLgorCSAqLworCWlmICh6aW9f YXJlbmEgIT0gTlVMTCAmJgorCSAgICB2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0ZSRUUpIDwK KwkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fQUxMT0MpID4+IDQpKQogCQlyZXR1cm4g KDEpOwogI2VuZGlmCS8qIHN1biAqLwotCi0jZWxzZQorI2Vsc2UJLyogX0tFUk5FTCAqLwogCWlm IChzcGFfZ2V0X3JhbmRvbSgxMDApID09IDApCiAJCXJldHVybiAoMSk7Ci0jZW5kaWYKKyNlbmRp ZgkvKiBfS0VSTkVMICovCisJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9ubyk7CisKIAlyZXR1 cm4gKDApOwogfQogCiBleHRlcm4ga21lbV9jYWNoZV90CSp6aW9fYnVmX2NhY2hlW107CiBleHRl cm4ga21lbV9jYWNoZV90CSp6aW9fZGF0YV9idWZfY2FjaGVbXTsKK2V4dGVybiBrbWVtX2NhY2hl X3QJKnJhbmdlX3NlZ19jYWNoZTsKIAotc3RhdGljIHZvaWQKK3N0YXRpYyB2b2lkIF9fbm9pbmxp bmUKIGFyY19rbWVtX3JlYXBfbm93KGFyY19yZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiB7CiAJ c2l6ZV90CQkJaTsKQEAgLTI1MjksNiArMjY4MCw3IEBAIGFyY19rbWVtX3JlYXBfbm93KGFyY19y ZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJa21lbV9jYWNoZV90CQkqcHJldl9jYWNoZSA9IE5V TEw7CiAJa21lbV9jYWNoZV90CQkqcHJldl9kYXRhX2NhY2hlID0gTlVMTDsKIAorCURUUkFDRV9Q Uk9CRShhcmNfX2ttZW1fcmVhcF9zdGFydCk7CiAjaWZkZWYgX0tFUk5FTAogCWlmIChhcmNfbWV0 YV91c2VkID49IGFyY19tZXRhX2xpbWl0KSB7CiAJCS8qCkBAIC0yNTM3LDcgKzI2ODksNyBAQCBh cmNfa21lbV9yZWFwX25vdyhhcmNfcmVjbGFpbV9zdHJhdGVneV90IHN0cmF0KQogCQkgKi8KIAkJ ZG5sY19yZWR1Y2VfY2FjaGUoKHZvaWQgKikodWludHB0cl90KWFyY19yZWR1Y2VfZG5sY19wZXJj ZW50KTsKIAl9Ci0jaWYgZGVmaW5lZChfX2kzODYpCisjaWYgZGVmaW5lZChfX2kzODYpIHx8ICFk ZWZpbmVkKFVNQV9NRF9TTUFMTF9BTExPQykKIAkvKgogCSAqIFJlY2xhaW0gdW51c2VkIG1lbW9y eSBmcm9tIGFsbCBrbWVtIGNhY2hlcy4KIAkgKi8KQEAgLTI1NTIsMjAgKzI3MDQsMTMxIEBAIGFy Y19rbWVtX3JlYXBfbm93KGFyY19yZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJaWYgKHN0cmF0 ID09IEFSQ19SRUNMQUlNX0FHR1IpCiAJCWFyY19zaHJpbmsoKTsKIAorCSh2b2lkKSBhcmNfY2Fj aGVfcmVjbGFpbSgwLCBBUkNfQ0FDSEVfUkVDTEFJTV9GT1JDRSk7CisKKyNpZmRlZiBzdW4KKwkv KgorCSAqIEFzayB0aGUgdm1lbSBhcmVhbmEgdG8gcmVjbGFpbSB1bnVzZWQgbWVtb3J5IGZyb20g aXRzCisJICogcXVhbnR1bSBjYWNoZXMuCisJICovCisJaWYgKHppb19hcmVuYSAhPSBOVUxMICYm IHN0cmF0ID09IEFSQ19SRUNMQUlNX0FHR1IpCisJCXZtZW1fcWNhY2hlX3JlYXAoemlvX2FyZW5h KTsKKyNlbmRpZgorb3V0OgorCURUUkFDRV9QUk9CRShhcmNfX2ttZW1fcmVhcF9lbmQpOworfQor CisKK3N0YXRpYyBib29sZWFuX3QKK2FyY19jYWNoZV9yZWNsYWltX25lZWRlZCh1aW50NjRfdCBz aXplKQoreworCisJaWYgKHpmc19hcmNfY2FjaGVfdGFyZ2V0ICYmIGZyZWVtZW0gPCB6ZnNfYXJj X2NhY2hlX3RhcmdldCArIGJ0b3Aoc2l6ZSkpIHsKKwkJRFRSQUNFX1BST0JFMShhcmNfY2FjaGVf cmVjbGFpbV9uZWVkZWQsIGludCwgQl9UUlVFKTsKKwkJcmV0dXJuIChCX1RSVUUpOworCX0KKwor CURUUkFDRV9QUk9CRTEoYXJjX2NhY2hlX3JlY2xhaW1fbmVlZGVkLCBpbnQsIEJfRkFMU0UpOwor CXJldHVybiAoQl9GQUxTRSk7Cit9CisKK3N0YXRpYyBib29sZWFuX3QKK2FyY19jYWNoZV9yZWNs YWltX3N0cmF0KGttZW1fY2FjaGVfdCAqY2FjaGUsIHVpbnQ2NF90IHNpemUsCisgICAgYXJjX2Nh Y2hlX3JlY2xhaW1fc3RyYXRlZ3lfdCBzdHJhdCkKK3sKKworCXN3aXRjaChzdHJhdCkgeworCWNh c2UgQVJDX0NBQ0hFX1JFQ0xBSU1fTk9XOgorCWNhc2UgQVJDX0NBQ0hFX1JFQ0xBSU1fRk9SQ0U6 CisJCWttZW1fY2FjaGVfcmVhcF9ub3coY2FjaGUpOworCQlpZiAoemZzX2FyY19jYWNoZV9wYXJ0 aWFsICYmIHN0cmF0ICE9IEFSQ19DQUNIRV9SRUNMQUlNX0ZPUkNFICYmCisJCSAgICAhYXJjX2Nh Y2hlX3JlY2xhaW1fbmVlZGVkKHNpemUpKSB7CisJCQlyZXR1cm4gKEJfVFJVRSk7CisJCX0KKwkJ YnJlYWs7CisJZGVmYXVsdDoKKwkJa21lbV9jYWNoZV9yZWFwKGNhY2hlLCB6ZnNfYXJjX2NhY2hl X2ZyZWVfbWF4KTsKKwl9CisKKwlyZXR1cm4gKEJfRkFMU0UpOworfQorCitzdGF0aWMgYm9vbGVh bl90CithcmNfY2FjaGVfcmVjbGFpbSh1aW50NjRfdCBzaXplLCBhcmNfY2FjaGVfcmVjbGFpbV9z dHJhdGVneV90IHN0cmF0KQoreworCWludCBpOworCWNsb2NrX3Qgbm93OworCWttZW1fY2FjaGVf dCAqcHJldl9jYWNoZSwgKnByZXZfZGF0YV9jYWNoZTsKKworCWlmIChzdHJhdCAhPSBBUkNfQ0FD SEVfUkVDTEFJTV9GT1JDRSkgeworCQlub3cgPSBkZGlfZ2V0X2xib2x0KCk7CisJCURUUkFDRV9Q Uk9CRTMoYXJjX2NhY2hlX3JlY2xhaW1fdGVzdCwgaW50LCBzdHJhdCwgaW50NjRfdCwgbm93LAor CQkgICAgaW50NjRfdCwgY2FjaGVfcmVjbGFpbV9sYXN0KTsKKwkJaWYgKG5vdyAtIGNhY2hlX3Jl Y2xhaW1fbGFzdCA+ICh6ZnNfYXJjX2NhY2hlX3BlcmlvZCAqIGh6KSkKKwkJCXJldHVybiAoQl9G QUxTRSk7CisJfQorCisJRFRSQUNFX1BST0JFMShhcmNfY2FjaGVfcmVjbGFpbSwgaW50LCBzdHJh dCk7CisKIAlmb3IgKGkgPSAwOyBpIDwgU1BBX01BWEJMT0NLU0laRSA+PiBTUEFfTUlOQkxPQ0tT SElGVDsgaSsrKSB7CiAJCWlmICh6aW9fYnVmX2NhY2hlW2ldICE9IHByZXZfY2FjaGUpIHsKIAkJ CXByZXZfY2FjaGUgPSB6aW9fYnVmX2NhY2hlW2ldOwotCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6 aW9fYnVmX2NhY2hlW2ldKTsKKwkJCWlmIChhcmNfY2FjaGVfcmVjbGFpbV9zdHJhdCh6aW9fYnVm X2NhY2hlW2ldLCBzaXplLAorCQkJICAgIHN0cmF0KSkgeworCQkJCXJldHVybiAoQl9UUlVFKTsK KwkJCX0KKwogCQl9CiAJCWlmICh6aW9fZGF0YV9idWZfY2FjaGVbaV0gIT0gcHJldl9kYXRhX2Nh Y2hlKSB7CiAJCQlwcmV2X2RhdGFfY2FjaGUgPSB6aW9fZGF0YV9idWZfY2FjaGVbaV07Ci0JCQlr bWVtX2NhY2hlX3JlYXBfbm93KHppb19kYXRhX2J1Zl9jYWNoZVtpXSk7CisJCQlpZiAoYXJjX2Nh Y2hlX3JlY2xhaW1fc3RyYXQoemlvX2RhdGFfYnVmX2NhY2hlW2ldLAorCQkJICAgIHNpemUsIHN0 cmF0KSkKKwkJCQlyZXR1cm4gKEJfVFJVRSk7CiAJCX0KIAl9Ci0Ja21lbV9jYWNoZV9yZWFwX25v dyhidWZfY2FjaGUpOwotCWttZW1fY2FjaGVfcmVhcF9ub3coaGRyX2NhY2hlKTsKKwlpZiAoYXJj X2NhY2hlX3JlY2xhaW1fc3RyYXQocmFuZ2Vfc2VnX2NhY2hlLCBzaXplLCBzdHJhdCkpCisJCXJl dHVybiAoQl9UUlVFKTsKKworCWlmIChhcmNfY2FjaGVfcmVjbGFpbV9zdHJhdChidWZfY2FjaGUs IHNpemUsIHN0cmF0KSkKKwkJcmV0dXJuIChCX1RSVUUpOworCisJYXJjX2NhY2hlX3JlY2xhaW1f c3RyYXQoaGRyX2NhY2hlLCBzaXplLCBzdHJhdCk7CisKKwljYWNoZV9yZWNsYWltX2xhc3QgPSBk ZGlfZ2V0X2xib2x0KCk7CisKKwlpZiAoYXJjX2NhY2hlX3JlY2xhaW1fbmVlZGVkKHNpemUpKQor CQlyZXR1cm4gKEJfRkFMU0UpOworCisJcmV0dXJuIChCX1RSVUUpOwogfQogCitzdGF0aWMgdWlu dDY0X3QKK2FyY19jYWNoZV9mcmVlKHZvaWQpCit7CisJaW50IGk7CisJdWludDY0X3QgY2FjaGVm cmVlOworCWttZW1fY2FjaGVfdCAqcHJldl9jYWNoZSwgKnByZXZfZGF0YV9jYWNoZTsKKworCWNh Y2hlZnJlZSA9IGttZW1fY2FjaGVfZnJlZV9zaXplKGJ1Zl9jYWNoZSkgKworCSAgICBrbWVtX2Nh Y2hlX2ZyZWVfc2l6ZShoZHJfY2FjaGUpOworCisJcHJldl9jYWNoZSA9IE5VTEw7CisJcHJldl9k YXRhX2NhY2hlID0gTlVMTDsKKworICAgICAgICBmb3IgKGkgPSAwOyBpIDwgU1BBX01BWEJMT0NL U0laRSA+PiBTUEFfTUlOQkxPQ0tTSElGVDsgaSsrKSB7CisgICAgICAgICAgICAgICAgaWYgKHpp b19idWZfY2FjaGVbaV0gIT0gcHJldl9jYWNoZSkgeworICAgICAgICAgICAgICAgICAgICAgICAg cHJldl9jYWNoZSA9IHppb19idWZfY2FjaGVbaV07CisgICAgICAgICAgICAgICAgICAgICAgICBj YWNoZWZyZWUgKz0ga21lbV9jYWNoZV9mcmVlX3NpemUoemlvX2J1Zl9jYWNoZVtpXSk7CisgICAg ICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIGlmICh6aW9fZGF0YV9idWZfY2FjaGVbaV0g IT0gcHJldl9kYXRhX2NhY2hlKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBwcmV2X2RhdGFf Y2FjaGUgPSB6aW9fZGF0YV9idWZfY2FjaGVbaV07CisgICAgICAgICAgICAgICAgICAgICAgICBj YWNoZWZyZWUgKz0ga21lbV9jYWNoZV9mcmVlX3NpemUoemlvX2RhdGFfYnVmX2NhY2hlW2ldKTsK KyAgICAgICAgICAgICAgICB9CisgICAgICAgIH0KKworCXJldHVybiAoY2FjaGVmcmVlKTsKK30K Kwogc3RhdGljIHZvaWQKIGFyY19yZWNsYWltX3RocmVhZCh2b2lkICpkdW1teSBfX3VudXNlZCkK IHsKQEAgLTI1NzcsMTAgKzI4NDAsMjggQEAgYXJjX3JlY2xhaW1fdGhyZWFkKHZvaWQgKmR1bW15 IF9fdW51c2VkKQogCiAJbXV0ZXhfZW50ZXIoJmFyY19yZWNsYWltX3Rocl9sb2NrKTsKIAl3aGls ZSAoYXJjX3RocmVhZF9leGl0ID09IDApIHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV90 aHJlYWQpOworCQlpZiAoYXJjX2NhY2hlX3JlY2xhaW1fbmVlZGVkKDApKSB7CisJCQkodm9pZCkg YXJjX2NhY2hlX3JlY2xhaW0oMCwgQVJDX0NBQ0hFX1JFQ0xBSU1fTk9XKTsKKwkJfSBlbHNlIHsK KwkJCWNsb2NrX3Qgbm93OworCisJCQlub3cgPSBkZGlfZ2V0X2xib2x0KCk7CisJCQlEVFJBQ0Vf UFJPQkUyKGFyY19fcmVjbGFpbV9jaGVjaywgaW50NjRfdCwgbm93LAorCQkJCWludDY0X3QsIGNh Y2hlX3JlY2xhaW1fbGFzdCk7CisJCQlpZiAobm93IC0gY2FjaGVfcmVjbGFpbV9sYXN0ID4KKwkJ CSAgICAoemZzX2FyY19jYWNoZV9mcmVlX3BlcmlvZCAqIGh6KSkgeworCQkJCSh2b2lkKSBhcmNf Y2FjaGVfcmVjbGFpbSgwLAorCQkJCSAgICBBUkNfQ0FDSEVfUkVDTEFJTV9TSVpFKTsKKwkJCX0K KwkJfQorCiAJCWlmIChhcmNfcmVjbGFpbV9uZWVkZWQoKSkgewotCisJCQlEVFJBQ0VfUFJPQkUx KGFyY19fY2FjaGVzX2ZyZWUsIHVpbnQ2NF90LAorCQkJICAgIGFyY19jYWNoZV9mcmVlKCkpOwog CQkJaWYgKGFyY19ub19ncm93KSB7CiAJCQkJaWYgKGxhc3RfcmVjbGFpbSA9PSBBUkNfUkVDTEFJ TV9DT05TKSB7CisJCQkJCURUUkFDRV9QUk9CRShhcmNfX3JlY2xhaW1fYWdncl9ub19ncm93KTsK IAkJCQkJbGFzdF9yZWNsYWltID0gQVJDX1JFQ0xBSU1fQUdHUjsKIAkJCQl9IGVsc2UgewogCQkJ CQlsYXN0X3JlY2xhaW0gPSBBUkNfUkVDTEFJTV9DT05TOwpAQCAtMjU4OCw2ICsyODY5LDcgQEAg YXJjX3JlY2xhaW1fdGhyZWFkKHZvaWQgKmR1bW15IF9fdW51c2VkKQogCQkJfSBlbHNlIHsKIAkJ CQlhcmNfbm9fZ3JvdyA9IFRSVUU7CiAJCQkJbGFzdF9yZWNsYWltID0gQVJDX1JFQ0xBSU1fQUdH UjsKKwkJCQlEVFJBQ0VfUFJPQkUoYXJjX19yZWNsYWltX2FnZ3IpOwogCQkJCW1lbWJhcl9wcm9k dWNlcigpOwogCQkJfQogCkBAIC0yNjAyLDYgKzI4ODQsNyBAQCBhcmNfcmVjbGFpbV90aHJlYWQo dm9pZCAqZHVtbXkgX191bnVzZWQpCiAJCQkJICovCiAJCQkJYXJjX25vX2dyb3cgPSBUUlVFOwog CQkJCWxhc3RfcmVjbGFpbSA9IEFSQ19SRUNMQUlNX0FHR1I7CisJCQkJRFRSQUNFX1BST0JFKGFy Y19fcmVjbGFpbV9hZ2dyX25lZWRmcmVlKTsKIAkJCX0KIAkJCWFyY19rbWVtX3JlYXBfbm93KGxh c3RfcmVjbGFpbSk7CiAJCQlhcmNfd2FybSA9IEJfVFJVRTsKQEAgLTI2MTgsNiArMjkwMSw3IEBA IGFyY19yZWNsYWltX3RocmVhZCh2b2lkICpkdW1teSBfX3VudXNlZCkKICNpZmRlZiBfS0VSTkVM CiAJCWlmIChuZWVkZnJlZSkgewogCQkJbmVlZGZyZWUgPSAwOworCQkJRFRSQUNFX1BST0JFKGFy Y19fY2xlYXJfbmVlZGZyZWUpOwogCQkJd2FrZXVwKCZuZWVkZnJlZSk7CiAJCX0KICNlbmRpZgpA QCAtMjY5Miw2ICsyOTc2LDcgQEAgYXJjX2FkYXB0KGludCBieXRlcywgYXJjX3N0YXRlX3QgKnN0 YXRlKQogCSAqIGNhY2hlIHNpemUsIGluY3JlbWVudCB0aGUgdGFyZ2V0IGNhY2hlIHNpemUKIAkg Ki8KIAlpZiAoYXJjX3NpemUgPiBhcmNfYyAtICgyVUxMIDw8IFNQQV9NQVhCTE9DS1NISUZUKSkg eworCQlEVFJBQ0VfUFJPQkUxKGFyY19faW5jX2FkYXB0LCBpbnQsIGJ5dGVzKTsKIAkJYXRvbWlj X2FkZF82NCgmYXJjX2MsIChpbnQ2NF90KWJ5dGVzKTsKIAkJaWYgKGFyY19jID4gYXJjX2NfbWF4 KQogCQkJYXJjX2MgPSBhcmNfY19tYXg7CkBAIC0yNzEzLDIwICsyOTk4LDYgQEAgYXJjX2V2aWN0 X25lZWRlZChhcmNfYnVmX2NvbnRlbnRzX3QgdHlwZSkKIAlpZiAodHlwZSA9PSBBUkNfQlVGQ19N RVRBREFUQSAmJiBhcmNfbWV0YV91c2VkID49IGFyY19tZXRhX2xpbWl0KQogCQlyZXR1cm4gKDEp OwogCi0jaWZkZWYgc3VuCi0jaWZkZWYgX0tFUk5FTAotCS8qCi0JICogSWYgemlvIGRhdGEgcGFn ZXMgYXJlIGJlaW5nIGFsbG9jYXRlZCBvdXQgb2YgYSBzZXBhcmF0ZSBoZWFwIHNlZ21lbnQsCi0J ICogdGhlbiBlbmZvcmNlIHRoYXQgdGhlIHNpemUgb2YgYXZhaWxhYmxlIHZtZW0gZm9yIHRoaXMg YXJlYSByZW1haW5zCi0JICogYWJvdmUgYWJvdXQgMS8zMm5kIGZyZWUuCi0JICovCi0JaWYgKHR5 cGUgPT0gQVJDX0JVRkNfREFUQSAmJiB6aW9fYXJlbmEgIT0gTlVMTCAmJgotCSAgICB2bWVtX3Np emUoemlvX2FyZW5hLCBWTUVNX0ZSRUUpIDwKLQkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZN RU1fQUxMT0MpID4+IDUpKQotCQlyZXR1cm4gKDEpOwotI2VuZGlmCi0jZW5kaWYJLyogc3VuICov Ci0KIAlpZiAoYXJjX3JlY2xhaW1fbmVlZGVkKCkpCiAJCXJldHVybiAoMSk7CiAKQEAgLTI3NjMs NiArMzAzNCw5IEBAIGFyY19nZXRfZGF0YV9idWYoYXJjX2J1Zl90ICpidWYpCiAJdWludDY0X3QJ CXNpemUgPSBidWYtPmJfaGRyLT5iX3NpemU7CiAJYXJjX2J1Zl9jb250ZW50c190CXR5cGUgPSBi dWYtPmJfaGRyLT5iX3R5cGU7CiAKKwlpZiAoYXJjX2NhY2hlX3JlY2xhaW1fbmVlZGVkKHNpemUp KQorCQkodm9pZCkgYXJjX2NhY2hlX3JlY2xhaW0oc2l6ZSwgQVJDX0NBQ0hFX1JFQ0xBSU1fTk9X KTsKKwogCWFyY19hZGFwdChzaXplLCBzdGF0ZSk7CiAKIAkvKgpAQCAtMzg4NSwyMCArNDE1OSwx NiBAQCBzdGF0aWMgaW50CiBhcmNfbWVtb3J5X3Rocm90dGxlKHVpbnQ2NF90IHJlc2VydmUsIHVp bnQ2NF90IHR4ZykKIHsKICNpZmRlZiBfS0VSTkVMCi0JdWludDY0X3QgYXZhaWxhYmxlX21lbW9y eSA9Ci0JICAgIHB0b2EoKHVpbnRtYXhfdCljbnQudl9mcmVlX2NvdW50ICsgY250LnZfY2FjaGVf Y291bnQpOworCXVpbnQ2NF90IGF2YWlsYWJsZV9tZW1vcnkgPSBwdG9iKGZyZWVtZW0pOwogCXN0 YXRpYyB1aW50NjRfdCBwYWdlX2xvYWQgPSAwOwogCXN0YXRpYyB1aW50NjRfdCBsYXN0X3R4ZyA9 IDA7CiAKLSNpZmRlZiBzdW4KLSNpZiBkZWZpbmVkKF9faTM4NikKKyNpZiBkZWZpbmVkKF9faTM4 NikgfHwgIWRlZmluZWQoVU1BX01EX1NNQUxMX0FMTE9DKQogCWF2YWlsYWJsZV9tZW1vcnkgPQot CSAgICBNSU4oYXZhaWxhYmxlX21lbW9yeSwgdm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJF RSkpOworCSAgICBNSU4oYXZhaWxhYmxlX21lbW9yeSwgcHRvYih2bWVtX3NpemUoaGVhcF9hcmVu YSwgVk1FTV9GUkVFKSkpOwogI2VuZGlmCi0jZW5kaWYJLyogc3VuICovCiAKLQlpZiAoY250LnZf ZnJlZV9jb3VudCArIGNudC52X2NhY2hlX2NvdW50ID4KLQkgICAgKHVpbnQ2NF90KXBoeXNtZW0g KiBhcmNfbG90c2ZyZWVfcGVyY2VudCAvIDEwMCkKKwlpZiAoZnJlZW1lbSA+ICh1aW50NjRfdClw aHlzbWVtICogYXJjX2xvdHNmcmVlX3BlcmNlbnQgLyAxMDApCiAJCXJldHVybiAoMCk7CiAKIAlp ZiAodHhnID4gbGFzdF90eGcpIHsKQEAgLTM5MTEsNyArNDE4MSw3IEBAIGFyY19tZW1vcnlfdGhy b3R0bGUodWludDY0X3QgcmVzZXJ2ZSwgdWludDY0X3QgdHhnCiAJICogY29udGludWUgdG8gbGV0 IHBhZ2Ugd3JpdGVzIG9jY3VyIGFzIHF1aWNrbHkgYXMgcG9zc2libGUuCiAJICovCiAJaWYgKGN1 cnByb2MgPT0gcGFnZXByb2MpIHsKLQkJaWYgKHBhZ2VfbG9hZCA+IGF2YWlsYWJsZV9tZW1vcnkg LyA0KQorCQlpZiAocGFnZV9sb2FkID4gTUFYKHB0b2IobWluZnJlZSksIGF2YWlsYWJsZV9tZW1v cnkpIC8gNCkKIAkJCXJldHVybiAoU0VUX0VSUk9SKEVSRVNUQVJUKSk7CiAJCS8qIE5vdGU6IHJl c2VydmUgaXMgaW5mbGF0ZWQsIHNvIHdlIGRlZmxhdGUgKi8KIAkJcGFnZV9sb2FkICs9IHJlc2Vy dmUgLyA4OwpAQCAtMzkzOSw4ICs0MjA5LDEwIEBAIGFyY190ZW1wcmVzZXJ2ZV9zcGFjZSh1aW50 NjRfdCByZXNlcnZlLCB1aW50NjRfdCB0CiAJaW50IGVycm9yOwogCXVpbnQ2NF90IGFub25fc2l6 ZTsKIAotCWlmIChyZXNlcnZlID4gYXJjX2MvNCAmJiAhYXJjX25vX2dyb3cpCisJaWYgKHJlc2Vy dmUgPiBhcmNfYy80ICYmICFhcmNfbm9fZ3JvdykgewogCQlhcmNfYyA9IE1JTihhcmNfY19tYXgs IHJlc2VydmUgKiA0KTsKKwkJRFRSQUNFX1BST0JFMShhcmNfX3NldF9yZXNlcnZlLCB1aW50NjRf dCwgYXJjX2MpOworCX0KIAlpZiAocmVzZXJ2ZSA+IGFyY19jKQogCQlyZXR1cm4gKFNFVF9FUlJP UihFTk9NRU0pKTsKIApAQCAtMzk5NCw2ICs0MjY2LDcgQEAgYXJjX2xvd21lbSh2b2lkICphcmcg X191bnVzZWQsIGludCBob3d0byBfX3VudXNlZCkKIAltdXRleF9lbnRlcigmYXJjX2xvd21lbV9s b2NrKTsKIAltdXRleF9lbnRlcigmYXJjX3JlY2xhaW1fdGhyX2xvY2spOwogCW5lZWRmcmVlID0g MTsKKwlEVFJBQ0VfUFJPQkUoYXJjX19uZWVkZnJlZSk7CiAJY3Zfc2lnbmFsKCZhcmNfcmVjbGFp bV90aHJfY3YpOwogCiAJLyoKSW5kZXg6IHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRz L2NvbW1vbi9mcy96ZnMvcmFuZ2VfdHJlZS5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9jZGRsL2NvbnRy aWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvcmFuZ2VfdHJlZS5jCShyZXZpc2lvbiAy NzIwMDUpCisrKyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZz L3JhbmdlX3RyZWUuYwkod29ya2luZyBjb3B5KQpAQCAtMzMsNyArMzMsNyBAQAogI2luY2x1ZGUg PHN5cy96aW8uaD4KICNpbmNsdWRlIDxzeXMvcmFuZ2VfdHJlZS5oPgogCi1zdGF0aWMga21lbV9j YWNoZV90ICpyYW5nZV9zZWdfY2FjaGU7CitrbWVtX2NhY2hlX3QgKnJhbmdlX3NlZ19jYWNoZTsK IAogdm9pZAogcmFuZ2VfdHJlZV9pbml0KHZvaWQpCkluZGV4OiBzeXMvY2RkbC9jb250cmliL29w ZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3ZkZXZfcXVldWUuYwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBz eXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3ZkZXZfcXVldWUu YwkocmV2aXNpb24gMjcyMDA1KQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMv Y29tbW9uL2ZzL3pmcy92ZGV2X3F1ZXVlLmMJKHdvcmtpbmcgY29weSkKQEAgLTMxMiw2ICszMTIs OCBAQCB2ZGV2X3F1ZXVlX2lvX2FkZCh2ZGV2X3F1ZXVlX3QgKnZxLCB6aW9fdCAqemlvKQogCUFT U0VSVChNVVRFWF9IRUxEKCZ2cS0+dnFfbG9jaykpOwogCUFTU0VSVDNVKHppby0+aW9fcHJpb3Jp dHksIDwsIFpJT19QUklPUklUWV9OVU1fUVVFVUVBQkxFKTsKIAlhdmxfYWRkKCZ2cS0+dnFfY2xh c3NbemlvLT5pb19wcmlvcml0eV0udnFjX3F1ZXVlZF90cmVlLCB6aW8pOworCURUUkFDRV9QUk9C RTModmRldl9xdWV1ZSwgdmRldl9xdWV1ZV90ICosIHZxLCB6aW9fdCAqLCB6aW8sIHVpbnQ2NF90 LAorCSAgICBhdmxfbnVtbm9kZXMoJnZxLT52cV9jbGFzc1t6aW8tPmlvX3ByaW9yaXR5XS52cWNf cXVldWVkX3RyZWUpKTsKIAogI2lmZGVmIGlsbHVtb3MKIAltdXRleF9lbnRlcigmc3BhLT5zcGFf aW9rc3RhdF9sb2NrKTsKSW5kZXg6IHN5cy92bS91bWEuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvdm0v dW1hLmgJKHJldmlzaW9uIDI3MjAwNSkKKysrIHN5cy92bS91bWEuaAkod29ya2luZyBjb3B5KQpA QCAtNjM2LDYgKzYzNiwxNyBAQCBpbnQgdW1hX3pvbmVfZXhoYXVzdGVkKHVtYV96b25lX3Qgem9u ZSk7CiBpbnQgdW1hX3pvbmVfZXhoYXVzdGVkX25vbG9jayh1bWFfem9uZV90IHpvbmUpOwogCiAv KgorICogVXNlZCB0byBkZXRlcm1pbmUgdGhlIGFtb3VudCBvZiBtZW1vcnkgY29uc3VtZWQgYnkg YSB6b25lJ3MgZnJlZSBzcGFjZS4KKyAqCisgKiBBcmd1bWVudHM6CisgKgl6b25lCVRoZSB6b25l IHRvIGRldGVybWluZSB0aGUgZnJlZSBzcGFjZSBvZi4KKyAqCisgKiBSZXR1cm5zOgorICoJdWlu dDY0X3QgVGhlIGFtb3VudCBvZiBtZW1vcnkgY29uc3VtZWQgYnkgdGhlIHpvbmUncyBmcmVlIHNw YWNlLgorICovCit1aW50NjRfdCB1bWFfem9uZV9mcmVlX3NpemUodW1hX3pvbmVfdCB6b25lKTsK KworLyoKICAqIENvbW1vbiBVTUFfWk9ORV9QQ1BVIHpvbmVzLgogICovCiBleHRlcm4gdW1hX3pv bmVfdCBwY3B1X3pvbmVfNjQ7CkluZGV4OiBzeXMvdm0vdW1hX2NvcmUuYwo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBzeXMvdm0vdW1hX2NvcmUuYwkocmV2aXNpb24gMjcyMDA1KQorKysgc3lzL3ZtL3VtYV9jb3Jl LmMJKHdvcmtpbmcgY29weSkKQEAgLTMzMTIsNiArMzMxMiwzMyBAQCB1bWFfcHJpbnRfem9uZSh1 bWFfem9uZV90IHpvbmUpCiAJfQogfQogCit1aW50NjRfdAordW1hX3pvbmVfZnJlZV9zaXplKHVt YV96b25lX3Qgem9uZSkKK3sKKwlpbnQgY3B1OworCXVpbnQ2NF90IGNhY2hlZnJlZTsKKwl1bWFf YnVja2V0X3QgYnVja2V0OworCXVtYV9jYWNoZV90IGNhY2hlOworCisJY2FjaGVmcmVlID0gMDsK KworCVpPTkVfTE9DSyh6b25lKTsKKwlMSVNUX0ZPUkVBQ0goYnVja2V0LCAmem9uZS0+dXpfYnVj a2V0cywgdWJfbGluaykKKwkJY2FjaGVmcmVlICs9ICh1aW50NjRfdClidWNrZXQtPnViX2NudDsK KworCUNQVV9GT1JFQUNIKGNwdSkgeworCQljYWNoZSA9ICZ6b25lLT51el9jcHVbY3B1XTsKKwkJ aWYgKGNhY2hlLT51Y19hbGxvY2J1Y2tldCAhPSBOVUxMKQorCQkJY2FjaGVmcmVlICs9ICh1aW50 NjRfdCljYWNoZS0+dWNfYWxsb2NidWNrZXQtPnViX2NudDsKKwkJaWYgKGNhY2hlLT51Y19mcmVl YnVja2V0ICE9IE5VTEwpCisJCQljYWNoZWZyZWUgKz0gKHVpbnQ2NF90KWNhY2hlLT51Y19mcmVl YnVja2V0LT51Yl9jbnQ7CisJfSAKKwljYWNoZWZyZWUgKj0gem9uZS0+dXpfc2l6ZTsKKwlaT05F X1VOTE9DSyh6b25lKTsKKworCXJldHVybiAoY2FjaGVmcmVlKTsKK30KKwogI2lmZGVmIEREQgog LyoKICAqIEdlbmVyYXRlIHN0YXRpc3RpY3MgYWNyb3NzIGJvdGggdGhlIHpvbmUgYW5kIGl0cyBw ZXItY3B1IGNhY2hlJ3MuICBSZXR1cm4KSW5kZXg6IHN5cy92bS92bV9wYWdlb3V0LmMKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkocmV2aXNpb24gMjcyMDA1KQorKysgc3lzL3Zt L3ZtX3BhZ2VvdXQuYwkod29ya2luZyBjb3B5KQpAQCAtNzYsNiArNzYsNyBAQAogX19GQlNESUQo IiRGcmVlQlNEJCIpOwogCiAjaW5jbHVkZSAib3B0X3ZtLmgiCisjaW5jbHVkZSAib3B0X2tkdHJh Y2UuaCIKICNpbmNsdWRlIDxzeXMvcGFyYW0uaD4KICNpbmNsdWRlIDxzeXMvc3lzdG0uaD4KICNp bmNsdWRlIDxzeXMva2VybmVsLmg+CkBAIC04OSw2ICs5MCw3IEBAIF9fRkJTRElEKCIkRnJlZUJT RCQiKTsKICNpbmNsdWRlIDxzeXMvcmFjY3QuaD4KICNpbmNsdWRlIDxzeXMvcmVzb3VyY2V2YXIu aD4KICNpbmNsdWRlIDxzeXMvc2NoZWQuaD4KKyNpbmNsdWRlIDxzeXMvc2R0Lmg+CiAjaW5jbHVk ZSA8c3lzL3NpZ25hbHZhci5oPgogI2luY2x1ZGUgPHN5cy9zbXAuaD4KICNpbmNsdWRlIDxzeXMv dm5vZGUuaD4KQEAgLTExNSwxMCArMTE3LDE0IEBAIF9fRkJTRElEKCIkRnJlZUJTRCQiKTsKIAog LyogdGhlIGtlcm5lbCBwcm9jZXNzICJ2bV9wYWdlb3V0IiovCiBzdGF0aWMgdm9pZCB2bV9wYWdl b3V0KHZvaWQpOworc3RhdGljIHZvaWQgdm1fcGFnZW91dF9pbml0KHZvaWQpOwogc3RhdGljIGlu dCB2bV9wYWdlb3V0X2NsZWFuKHZtX3BhZ2VfdCk7CiBzdGF0aWMgdm9pZCB2bV9wYWdlb3V0X3Nj YW4oc3RydWN0IHZtX2RvbWFpbiAqdm1kLCBpbnQgcGFzcyk7CiBzdGF0aWMgdm9pZCB2bV9wYWdl b3V0X21pZ2h0YmVfb29tKHN0cnVjdCB2bV9kb21haW4gKnZtZCwgaW50IHBhc3MpOwogCitTWVNJ TklUKHBhZ2VkYWVtb25faW5pdCwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfRklSU1Qs IHZtX3BhZ2VvdXRfaW5pdCwKKyAgICBOVUxMKTsKKwogc3RydWN0IHByb2MgKnBhZ2Vwcm9jOwog CiBzdGF0aWMgc3RydWN0IGtwcm9jX2Rlc2MgcGFnZV9rcCA9IHsKQEAgLTEyNiw5ICsxMzIsMTMg QEAgc3RhdGljIHN0cnVjdCBrcHJvY19kZXNjIHBhZ2Vfa3AgPSB7CiAJdm1fcGFnZW91dCwKIAkm cGFnZXByb2MKIH07Ci1TWVNJTklUKHBhZ2VkYWVtb24sIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJ X09SREVSX0ZJUlNULCBrcHJvY19zdGFydCwKK1NZU0lOSVQocGFnZWRhZW1vbiwgU0lfU1VCX0tU SFJFQURfUEFHRSwgU0lfT1JERVJfU0VDT05ELCBrcHJvY19zdGFydCwKICAgICAmcGFnZV9rcCk7 CiAKK1NEVF9QUk9WSURFUl9ERUZJTkUodm0pOworU0RUX1BST0JFX0RFRklORSh2bSwgLCAsIHZt X19sb3dtZW1fY2FjaGUpOworU0RUX1BST0JFX0RFRklORSh2bSwgLCAsIHZtX19sb3dtZW1fc2Nh bik7CisKICNpZiAhZGVmaW5lZChOT19TV0FQUElORykKIC8qIHRoZSBrZXJuZWwgcHJvY2VzcyAi dm1fZGFlbW9uIiovCiBzdGF0aWMgdm9pZCB2bV9kYWVtb24odm9pZCk7CkBAIC02NjMsNiArNjcz LDcgQEAgdm1fcGFnZW91dF9ncm93X2NhY2hlKGludCB0cmllcywgdm1fcGFkZHJfdCBsb3csIHYK IAkJICogbWF5IGFjcXVpcmUgbG9ja3MgYW5kL29yIHNsZWVwLCBzbyB0aGV5IGNhbiBvbmx5IGJl IGludm9rZWQKIAkJICogd2hlbiAidHJpZXMiIGlzIGdyZWF0ZXIgdGhhbiB6ZXJvLgogCQkgKi8K KwkJU0RUX1BST0JFMCh2bSwgLCAsIHZtX19sb3dtZW1fY2FjaGUpOwogCQlFVkVOVEhBTkRMRVJf SU5WT0tFKHZtX2xvd21lbSwgMCk7CiAKIAkJLyoKQEAgLTkyMSwxMCArOTMyLDExIEBAIHZtX3Bh Z2VvdXRfc2NhbihzdHJ1Y3Qgdm1fZG9tYWluICp2bWQsIGludCBwYXNzKQogCSAqIHNvbWUuICBX ZSByYXRlIGxpbWl0IHRvIGF2b2lkIHRocmFzaGluZy4KIAkgKi8KIAlpZiAodm1kID09ICZ2bV9k b21bMF0gJiYgcGFzcyA+IDAgJiYKLQkgICAgbG93bWVtX3RpY2tzICsgKGxvd21lbV9wZXJpb2Qg KiBoeikgPCB0aWNrcykgeworCSAgICAodGlja3MgLSBsb3dtZW1fdGlja3MpIC8gaHogPj0gbG93 bWVtX3BlcmlvZCkgewogCQkvKgogCQkgKiBEZWNyZWFzZSByZWdpc3RlcmVkIGNhY2hlIHNpemVz LgogCQkgKi8KKwkJU0RUX1BST0JFMCh2bSwgLCAsIHZtX19sb3dtZW1fc2Nhbik7CiAJCUVWRU5U SEFORExFUl9JTlZPS0Uodm1fbG93bWVtLCAwKTsKIAkJLyoKIAkJICogV2UgZG8gdGhpcyBleHBs aWNpdGx5IGFmdGVyIHRoZSBjYWNoZXMgaGF2ZSBiZWVuCkBAIC0xNjUwLDE1ICsxNjYyLDExIEBA IHZtX3BhZ2VvdXRfd29ya2VyKHZvaWQgKmFyZykKIH0KIAogLyoKLSAqCXZtX3BhZ2VvdXQgaXMg dGhlIGhpZ2ggbGV2ZWwgcGFnZW91dCBkYWVtb24uCisgKgl2bV9wYWdlb3V0X2luaXQgaW5pdGlh bGlzZXMgYmFzaWMgcGFnZW91dCBkYWVtb24gc2V0dGluZ3MuCiAgKi8KIHN0YXRpYyB2b2lkCi12 bV9wYWdlb3V0KHZvaWQpCit2bV9wYWdlb3V0X2luaXQodm9pZCkKIHsKLSNpZiBNQVhNRU1ET00g PiAxCi0JaW50IGVycm9yLCBpOwotI2VuZGlmCi0KIAkvKgogCSAqIEluaXRpYWxpemUgc29tZSBw YWdpbmcgcGFyYW1ldGVycy4KIAkgKi8KQEAgLTE3MDQsNyArMTcxMiwxOCBAQCBzdGF0aWMgdm9p ZAogCS8qIFhYWCBkb2VzIG5vdCByZWFsbHkgYmVsb25nIGhlcmUgKi8KIAlpZiAodm1fcGFnZV9t YXhfd2lyZWQgPT0gMCkKIAkJdm1fcGFnZV9tYXhfd2lyZWQgPSBjbnQudl9mcmVlX2NvdW50IC8g MzsKK30KIAorLyoKKyAqICAgICB2bV9wYWdlb3V0IGlzIHRoZSBoaWdoIGxldmVsIHBhZ2VvdXQg ZGFlbW9uLgorICovCitzdGF0aWMgdm9pZAordm1fcGFnZW91dCh2b2lkKQoreworI2lmIE1BWE1F TURPTSA+IDEKKwlpbnQgZXJyb3IsIGk7CisjZW5kaWYKKwogCXN3YXBfcGFnZXJfc3dhcF9pbml0 KCk7CiAjaWYgTUFYTUVNRE9NID4gMQogCWZvciAoaSA9IDE7IGkgPCB2bV9uZG9tYWluczsgaSsr KSB7Cg== 147754 2014-09-28 15:44:48 +0000 2014-09-28 15:44:48 +0000 UMA summary script vmstat.awk text/plain 1548 smh IyEvdXNyL2Jpbi9hd2sgLWYKCgpCRUdJTiB7CglGUz0iLHw6IjsKCXVzZWQgPSAwOwoJZnJlZSA9 IDA7Cgl6dXNlZCA9IDA7Cgl6ZnJlZSA9IDA7Cn0KCmZ1bmN0aW9uIGhzaXplKHZhbCkKewoJaWYg KHZhbCA+IDEwMjQgXiAzKSB7CgkJcmV0dXJuIHNwcmludGYoIiUuM2ZHQiIsIHZhbCAvIDEwMjQg XjMpOwoJfSBlbHNlIGlmICh2YWwgPiAxMDI0IF4gMikgewoJCXJldHVybiBzcHJpbnRmKCIlLjBm TUIiLCB2YWwgLyAxMDI0IF4yKTsKCX0gZWxzZSBpZiAodmFsID4gMTAyNCkgewoJCXJldHVybiBz cHJpbnRmKCIlLjBmS0IiLCB2YWwgLyAxMDI0KTsKCX0KCglyZXR1cm4gc3ByaW50ZigiJWRiIiwg dmFsKTsKfQoKewoJaWYgKE5GICE9IDgpIHsKCQlpZiAoJDAgfiAvXklURU0vKSB7CgkJCXByaW50 ICJJVEVNICAgICAgICAgICAgICAgICAgICAgIFNJWkUgICAgICBMSU1JVCAgICAgICBVU0VEICAg ICAgIEZSRUUgICAgICAgIFJFUSAgICAgICBGQUlMICAgICAgU0xFRVAgICAgVVNFRChIKSAgICBG UkVFKEgpICAgVE9UQUwoSCkgICBGUkVFJSI7CgkJfQoJfSBlbHNlIHsKCQl1c2VkICs9ICgkMiAq ICQ0KTsKCQlmcmVlICs9ICgkMiAqICQ1KTsKCQlnc3ViKC9eWyBcdF0rLywiIiwkMik7CgkJZ3N1 YigvXlsgXHRdKy8sIiIsJDMpOwoJCWdzdWIoL15bIFx0XSsvLCIiLCQ0KTsKCQlnc3ViKC9eWyBc dF0rLywiIiwkNSk7CgkJZ3N1YigvXlsgXHRdKy8sIiIsJDYpOwoJCWdzdWIoL15bIFx0XSsvLCIi LCQ3KTsKCQlpZiAoJDUgPT0gMCkgewoJCQlmcmVlcGN0ID0gMDsKCQl9IGVsc2UgewoJCQlmcmVl cGN0ID0gc3ByaW50ZigiJWQlJSIsICQ1IC8gKCgkNCArICQ1KSAvIDEwMCkpOwoJCX0KCQl3YXJu ID0gIiIKCQlpZiAoKCQyICogJDUpID4gNTAgKiAoMTAyNCBeIDIpKSB7CgkJCXdhcm4gPSAiKioi CgkJfQoJCXByaW50ZigiJS0yNHMlNnMsJTEwcywlMTBzLCUxMHMsJTEwcywlMTBzLCUxMHMsJTEw cywlMTBzLCUxMHMsJTEwcyVzXG4iLCAkMSI6IiwgJDIsICQzLCAkNCwgJDUsICQ2LCAkNywgJDgs IGhzaXplKCQyICogJDQpLCBoc2l6ZSgkMiAqICQ1KSwgaHNpemUoJDIgKiAoJDQgKyAkNSkpLCBm cmVlcGN0LCB3YXJuKTsKCQlpZiAoJDEgfiAvXmFyY198ZG11X3xkbm9kZV98bHo0X3xyYW5nZV9z ZWdffHJlZmVyZW5jZV98c2FffHpmc198emlvXy8pIHsKCQkJenVzZWQgKz0gKCQyICogJDQpOwoJ CQl6ZnJlZSArPSAoJDIgKiAkNSk7CgkJfQoJfQp9CgpFTkQgewoJcHJpbnQgIlRvdGFscyIKCXBy aW50ICJvdXNlZDogIiBoc2l6ZSh1c2VkIC0genVzZWQpICIsIG9mcmVlOiAiIGhzaXplKGZyZWUg LSB6ZnJlZSkgIiwgb3RvdGFsOiAiIGhzaXplKChmcmVlICsgdXNlZCkgLSAoemZyZWUgKyB6dXNl ZCkpOwoJcHJpbnQgInp1c2VkOiAiIGhzaXplKHp1c2VkKSAiLCB6ZnJlZTogIiBoc2l6ZSh6ZnJl ZSkgIiwgenRvdGFsOiAiIGhzaXplKHpmcmVlICsgenVzZWQpOwoJcHJpbnQgInVzZWQ6ICIgaHNp emUodXNlZCkgIiwgZnJlZTogIiBoc2l6ZShmcmVlKSAiLCB0b3RhbDogIiBoc2l6ZShmcmVlICsg dXNlZCk7Cn0K 147815 2014-09-30 02:36:57 +0000 2014-09-30 02:36:57 +0000 ARC reclaim refactor + uma clear down (against stable/10) arc_cache_reclaim_uma_stable10.patch text/plain 27172 smh SW5kZXg6IHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0u Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb21wYXQvb3BlbnNvbGFyaXMva2Vybi9vcGVuc29s YXJpc19rbWVtLmMJKHJldmlzaW9uIDI3MjAwNSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29s YXJpcy9rZXJuL29wZW5zb2xhcmlzX2ttZW0uYwkod29ya2luZyBjb3B5KQpAQCAtMzQsNiArMzQs NyBAQCBfX0ZCU0RJRCgiJEZyZWVCU0QkIik7CiAjaW5jbHVkZSA8c3lzL2ttZW0uaD4KICNpbmNs dWRlIDxzeXMvZGVidWcuaD4KICNpbmNsdWRlIDxzeXMvbXV0ZXguaD4KKyNpbmNsdWRlIDxzeXMv c2R0Lmg+CiAKICNpbmNsdWRlIDx2bS92bV9wYWdlLmg+CiAjaW5jbHVkZSA8dm0vdm1fb2JqZWN0 Lmg+CkBAIC0xMzMsMTMgKzEzNCw2IEBAIGttZW1fc2l6ZSh2b2lkKQogCXJldHVybiAoa21lbV9z aXplX3ZhbCk7CiB9CiAKLXVpbnQ2NF90Ci1rbWVtX3VzZWQodm9pZCkKLXsKLQotCXJldHVybiAo dm1lbV9zaXplKGttZW1fYXJlbmEsIFZNRU1fQUxMT0MpKTsKLX0KLQogc3RhdGljIGludAoga21l bV9zdGRfY29uc3RydWN0b3Iodm9pZCAqbWVtLCBpbnQgc2l6ZSBfX3VudXNlZCwgdm9pZCAqcHJp dmF0ZSwgaW50IGZsYWdzKQogewpAQCAtMjI4LDEyICsyMjIsNDUgQEAga21lbV9jYWNoZV9yZWFw X25vdyhrbWVtX2NhY2hlX3QgKmNhY2hlKQogfQogCiB2b2lkCitrbWVtX2NhY2hlX3JlYXAoa21l bV9jYWNoZV90ICpjYWNoZSwgdWludDY0X3QgbWF4ZnJlZSkKK3sKKworCWlmIChjYWNoZS0+a2Nf em9uZSAhPSBOVUxMICYmCisJICAgIHVtYV96b25lX2ZyZWVfc2l6ZShjYWNoZS0+a2Nfem9uZSkg PiBtYXhmcmVlKQorCQl6b25lX2RyYWluKGNhY2hlLT5rY196b25lKTsKK30KKwordm9pZAoga21l bV9yZWFwKHZvaWQpCiB7CiAJdW1hX3JlY2xhaW0oKTsKIH0KKwordWludDY0X3QKK2ttZW1fY2Fj aGVfZnJlZV9zaXplKGttZW1fY2FjaGVfdCAqY2FjaGUpCit7CisJdWludDY0X3QgY2FjaGVmcmVl OworCisJY2FjaGVmcmVlID0gKGNhY2hlLT5rY196b25lID09IE5VTEwpID8gMCA6CisJICAgIHVt YV96b25lX2ZyZWVfc2l6ZShjYWNoZS0+a2Nfem9uZSk7CisKKwkvKgorCSAqIE1hbnVhbCBwcm9i ZSBhcyB0aGUgcmV0dXJuIGZidCBwcm9iZSBuZXZlciBmaXJlcyBkdWUgdG8KKwkgKiBjb21waWxl ciB0YWxsIGNhbGwgb3B0aW1pc2F0aW9uLgorCSAqLworCURUUkFDRV9QUk9CRTIoa21lbV9jYWNo ZV9mcmVlX3NpemUsIGNoYXIgKiwgY2FjaGUtPmtjX25hbWUsIHVpbnQ2NF90LAorCSAgICBjYWNo ZWZyZWUpOworCisJcmV0dXJuIChjYWNoZWZyZWUpOworfQorCiAjZWxzZQogdm9pZAora21lbV9j YWNoZV9yZWFwKGttZW1fY2FjaGVfdCAqY2FjaGUsIHVpbnQ2NF90IG1heGZyZWUpCit7Cit9CisK K3ZvaWQKIGttZW1fY2FjaGVfcmVhcF9ub3coa21lbV9jYWNoZV90ICpjYWNoZSBfX3VudXNlZCkK IHsKIH0KQEAgLTI0Miw2ICsyNjksMTEgQEAgdm9pZAoga21lbV9yZWFwKHZvaWQpCiB7CiB9CisK K3VpbnQ2NF90CitrbWVtX2NhY2hlX2ZyZWVfc2l6ZShrbWVtX2NhY2hlX3QgKmNhY2hlKQorewor fQogI2VuZGlmCiAKIGludApJbmRleDogc3lzL2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9r bWVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9rbWVt LmgJKHJldmlzaW9uIDI3MjAwNSkKKysrIHN5cy9jZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMv a21lbS5oCSh3b3JraW5nIGNvcHkpCkBAIC00NCw3ICs0NCw3IEBAIE1BTExPQ19ERUNMQVJFKE1f U09MQVJJUyk7CiAjZGVmaW5lCVBPSU5URVJfSU5WQUxJREFURShwcCkJKCoocHApID0gKHZvaWQg KikoKHVpbnRwdHJfdCkoKihwcCkpIHwgMHgxKSkKIAogI2RlZmluZQlLTV9TTEVFUAkJTV9XQUlU T0sKLSNkZWZpbmUJS01fUFVTSFBBR0UJCU1fV0FJVE9LCisjZGVmaW5lCUtNX1BVU0hQQUdFCQlN X1dBSVRPS3xNX1VTRV9SRVNFUlZFCiAjZGVmaW5lCUtNX05PU0xFRVAJCU1fTk9XQUlUCiAjZGVm aW5lCUtNX05PREVCVUcJCU1fTk9EVU1QCiAjZGVmaW5lCUtNX05PUk1BTFBSSQkJMApAQCAtNjYs NyArNjYsNiBAQCB0eXBlZGVmIHN0cnVjdCBrbWVtX2NhY2hlIHsKIHZvaWQgKnpmc19rbWVtX2Fs bG9jKHNpemVfdCBzaXplLCBpbnQga21mbGFncyk7CiB2b2lkIHpmc19rbWVtX2ZyZWUodm9pZCAq YnVmLCBzaXplX3Qgc2l6ZSk7CiB1aW50NjRfdCBrbWVtX3NpemUodm9pZCk7Ci11aW50NjRfdCBr bWVtX3VzZWQodm9pZCk7CiBrbWVtX2NhY2hlX3QgKmttZW1fY2FjaGVfY3JlYXRlKGNoYXIgKm5h bWUsIHNpemVfdCBidWZzaXplLCBzaXplX3QgYWxpZ24sCiAgICAgaW50ICgqY29uc3RydWN0b3Ip KHZvaWQgKiwgdm9pZCAqLCBpbnQpLCB2b2lkICgqZGVzdHJ1Y3Rvcikodm9pZCAqLCB2b2lkICop LAogICAgIHZvaWQgKCpyZWNsYWltKSh2b2lkICopIF9fdW51c2VkLCB2b2lkICpwcml2YXRlLCB2 bWVtX3QgKnZtcCwgaW50IGNmbGFncyk7CkBAIC03NCwxMCArNzMsMTUgQEAgdm9pZCBrbWVtX2Nh Y2hlX2Rlc3Ryb3koa21lbV9jYWNoZV90ICpjYWNoZSk7CiB2b2lkICprbWVtX2NhY2hlX2FsbG9j KGttZW1fY2FjaGVfdCAqY2FjaGUsIGludCBmbGFncyk7CiB2b2lkIGttZW1fY2FjaGVfZnJlZShr bWVtX2NhY2hlX3QgKmNhY2hlLCB2b2lkICpidWYpOwogdm9pZCBrbWVtX2NhY2hlX3JlYXBfbm93 KGttZW1fY2FjaGVfdCAqY2FjaGUpOwordm9pZCBrbWVtX2NhY2hlX3JlYXAoa21lbV9jYWNoZV90 ICpjYWNoZSwgdWludDY0X3QgbWF4ZnJlZSk7CiB2b2lkIGttZW1fcmVhcCh2b2lkKTsKK3VpbnQ2 NF90IGttZW1fY2FjaGVfZnJlZV9zaXplKGttZW1fY2FjaGVfdCAqY2FjaGUpOwogaW50IGttZW1f ZGVidWdnaW5nKHZvaWQpOwogdm9pZCAqY2FsbG9jKHNpemVfdCBuLCBzaXplX3Qgcyk7CiAKKyNk ZWZpbmUJZnJlZW1lbQkJCQkoY250LnZfZnJlZV9jb3VudCArIGNudC52X2NhY2hlX2NvdW50KQor I2RlZmluZQltaW5mcmVlCQkJCWNudC52X2ZyZWVfbWluCisjZGVmaW5lCWhlYXBfYXJlbmEJCQlr bWVtX2FyZW5hCiAjZGVmaW5lCWttZW1fYWxsb2Moc2l6ZSwga21mbGFncykJemZzX2ttZW1fYWxs b2MoKHNpemUpLCAoa21mbGFncykpCiAjZGVmaW5lCWttZW1femFsbG9jKHNpemUsIGttZmxhZ3Mp CXpmc19rbWVtX2FsbG9jKChzaXplKSwgKGttZmxhZ3MpIHwgTV9aRVJPKQogI2RlZmluZQlrbWVt X2ZyZWUoYnVmLCBzaXplKQkJemZzX2ttZW1fZnJlZSgoYnVmKSwgKHNpemUpKQpJbmRleDogc3lz L2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9wYXJhbS5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9j ZGRsL2NvbXBhdC9vcGVuc29sYXJpcy9zeXMvcGFyYW0uaAkocmV2aXNpb24gMjcyMDA1KQorKysg c3lzL2NkZGwvY29tcGF0L29wZW5zb2xhcmlzL3N5cy9wYXJhbS5oCSh3b3JraW5nIGNvcHkpCkBA IC0zNiw2ICszNiw3IEBACiAKICNpZmRlZiBfS0VSTkVMCiAjZGVmaW5lCXB0b2IoeCkJCSgodWlu dDY0X3QpKHgpIDw8IFBBR0VfU0hJRlQpCisjZGVmaW5lCWJ0b3AoeCkJCSgodWludDY0X3QpKHgp ID4+IFBBR0VfU0hJRlQpCiAjZW5kaWYKIAogI2VuZGlmCkluZGV4OiBzeXMvY2RkbC9jb250cmli L29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9j ZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvYXJjLmMJKHJldmlzaW9u IDI3MjAwNSkKKysrIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96 ZnMvYXJjLmMJKHdvcmtpbmcgY29weSkKQEAgLTEzOCw2ICsxMzgsNyBAQAogI2luY2x1ZGUgPHN5 cy9zZHQuaD4KIAogI2luY2x1ZGUgPHZtL3ZtX3BhZ2VvdXQuaD4KKyNpbmNsdWRlIDxtYWNoaW5l L3ZtcGFyYW0uaD4KIAogI2lmZGVmIGlsbHVtb3MKICNpZm5kZWYgX0tFUk5FTApAQCAtMTU5LDYg KzE2MCwxNSBAQCB0eXBlZGVmIGVudW0gYXJjX3JlY2xhaW1fc3RyYXRlZ3kgewogCUFSQ19SRUNM QUlNX0NPTlMJCS8qIENvbnNlcnZhdGl2ZSByZWNsYWltIHN0cmF0ZWd5ICovCiB9IGFyY19yZWNs YWltX3N0cmF0ZWd5X3Q7CiAKK3R5cGVkZWYgZW51bSBhcmNfY2FjaGVfcmVjbGFpbV9zdHJhZ2Vn eSB7CisJQVJDX0NBQ0hFX1JFQ0xBSU1fTk9XLAkJLyogSW1tZWRpYXRlIHJlY2xhaW0gc3RyYXRl Z3kgKi8KKwlBUkNfQ0FDSEVfUkVDTEFJTV9TSVpFLAkJLyogRnJlZSBzaXplIHJlY2xhaW0gc3Ry YXRlZ3kgKi8KKwlBUkNfQ0FDSEVfUkVDTEFJTV9GT1JDRSwJLyogRm9yY2VkIGltbWVkaWF0ZSBy ZWNsYWltIHN0cmF0ZWd5ICovCit9IGFyY19jYWNoZV9yZWNsYWltX3N0cmF0ZWd5X3Q7CisKKy8q IFdoZW4gdGhlIGxhc3QgY2FjaGUgcmVjbGFpbSB3YXMgcHJvY2Vzc2VkLiAqLworc3RhdGljIGNs b2NrX3QgYXJjX2NhY2hlX3JlY2xhaW1fbGFzdCA9IDA7CisKIC8qCiAgKiBUaGUgbnVtYmVyIG9m IGl0ZXJhdGlvbnMgdGhyb3VnaCBhcmNfZXZpY3RfKigpIGJlZm9yZSB3ZQogICogZHJvcCAmIHJl YWNxdWlyZSB0aGUgbG9jay4KQEAgLTE5Myw5ICsyMDMsNiBAQCBleHRlcm4gaW50IHpmc19wcmVm ZXRjaF9kaXNhYmxlOwogICovCiBzdGF0aWMgYm9vbGVhbl90IGFyY193YXJtOwogCi0vKgotICog VGhlc2UgdHVuYWJsZXMgYXJlIGZvciBwZXJmb3JtYW5jZSBhbmFseXNpcy4KLSAqLwogdWludDY0 X3QgemZzX2FyY19tYXg7CiB1aW50NjRfdCB6ZnNfYXJjX21pbjsKIHVpbnQ2NF90IHpmc19hcmNf bWV0YV9saW1pdCA9IDA7CkBAIC0yMDQsNyArMjExLDI3IEBAIGludCB6ZnNfYXJjX3Nocmlua19z aGlmdCA9IDA7CiBpbnQgemZzX2FyY19wX21pbl9zaGlmdCA9IDA7CiBpbnQgemZzX2Rpc2FibGVf ZHVwX2V2aWN0aW9uID0gMDsKIHVpbnQ2NF90IHpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUgPSA4 ICogMTAyNDsgLyogOEtCICovCit1X2ludCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gMDsKK3VfaW50 IHpmc19hcmNfY2FjaGVfdGFyZ2V0ID0gMDsKK2ludCB6ZnNfYXJjX2NhY2hlX3BlcmlvZCA9IDEw OworaW50IHpmc19hcmNfY2FjaGVfcGFydGlhbCA9IDA7CitpbnQgemZzX2FyY19jYWNoZV9mcmVl X3BlcmlvZCA9IDMwMDsKK3VpbnQ2NF90IHpmc19hcmNfY2FjaGVfZnJlZV9tYXggPSAoMSA8PDI0 KTsgLyogMTZNQiAqLwogCisjaWZkZWYgX0tFUk5FTAorc3RhdGljIGludCBzeXNjdGxfdmZzX3pm c19hcmNfZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CitzdGF0aWMgaW50IHN5c2N0 bF92ZnNfemZzX2FyY19jYWNoZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CisKK3N0YXRp YyB2b2lkCithcmNfdGFyZ2V0X2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQoreworCisJemZz X2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2VvdXRfd2FrZXVwX3RocmVzaDsKKwl6ZnNfYXJjX2Nh Y2hlX3RhcmdldCA9ICh2bV9wYWdlb3V0X3dha2V1cF90aHJlc2ggLyAyKSAqIDM7Cit9CitTWVNJ TklUKGFyY190YXJnZXRfaW5pdCwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfQU5ZLAor ICAgIGFyY190YXJnZXRfaW5pdCwgTlVMTCk7CisKIFRVTkFCTEVfUVVBRCgidmZzLnpmcy5hcmNf bWF4IiwgJnpmc19hcmNfbWF4KTsKIFRVTkFCTEVfUVVBRCgidmZzLnpmcy5hcmNfbWluIiwgJnpm c19hcmNfbWluKTsKIFRVTkFCTEVfUVVBRCgidmZzLnpmcy5hcmNfbWV0YV9saW1pdCIsICZ6ZnNf YXJjX21ldGFfbGltaXQpOwpAQCAtMjE3LDcgKzI0NCw3NSBAQCBTWVNDVExfVVFVQUQoX3Zmc196 ZnMsIE9JRF9BVVRPLCBhcmNfbWluLCBDVExGTEFHXwogU1lTQ1RMX1VRVUFEKF92ZnNfemZzLCBP SURfQVVUTywgYXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCBDVExGTEFHX1JEVFVOLAogICAgICZ6ZnNf YXJjX2F2ZXJhZ2VfYmxvY2tzaXplLCAwLAogICAgICJBUkMgYXZlcmFnZSBibG9ja3NpemUiKTsK K1NZU0NUTF9JTlQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfY2FjaGVfcmVjbGFpbV9wZXJpb2Qs IENUTEZMQUdfUldUVU4sCisgICAgJnpmc19hcmNfY2FjaGVfcGVyaW9kLCAwLAorICAgICJNaW4g bnVtYmVyIG9mIHNlY29uZHMgYmV0d2VlbiBBUkMgY2FjaGUgcmVjbGFpbXMiKTsKK1NZU0NUTF9V SU5UKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2NhY2hlX3JlY2xhaW1fcGFydGlhbCwgQ1RMRkxB R19SV1RVTiwKKyAgICAmemZzX2FyY19jYWNoZV9wYXJ0aWFsLCAwLAorICAgICJFbmFibGUgQVJD IHRvIHBlcmZvcm0gcGFydGlhbCBjYWNoZSByZWNsYWltcyIpOworU1lTQ1RMX1VRVUFEKF92ZnNf emZzLCBPSURfQVVUTywgYXJjX2NhY2hlX2ZyZWVfbWF4LCBDVExGTEFHX1JXVFVOLAorICAgICZ6 ZnNfYXJjX2NhY2hlX2ZyZWVfbWF4LCAwLAorICAgICJNYXhpbXVtIGZyZWUgYnl0ZXMgaW4gYW4g QVJDIGNhY2hlIHpvbmUgYmVmb3JlIHJlY2xhaW0gd2lsbCBiZSB0cmlnZ2VyZWQiKTsKK1NZU0NU TF9VSU5UKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2NhY2hlX2ZyZWVfcGVyaW9kLCBDVExGTEFH X1JXVFVOLAorICAgICZ6ZnNfYXJjX2NhY2hlX2ZyZWVfcGVyaW9kLCAwLAorICAgICJNaW4gbnVt YmVyIG9mIHNlY29uZHMgYmV0d2VlbiBBUkMgZnJlZSBzaXplIGJhc2VkIGNhY2hlIHJlY2xhaW1z Iik7CisvKgorICogV2UgZG9uJ3QgaGF2ZSBhIHR1bmFibGUgZm9yIHRoZXNlIHN5c2N0bHMgZHVl IHRvIHRoZWlyIGRlcGVuZGVuY3kgb24KKyAqIHBhZ2VkYWVtb24gaW5pdGlhbGlzYXRpb24uCisg Ki8KK1NZU0NUTF9QUk9DKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2ZyZWVfdGFyZ2V0LAorICAg IENUTFRZUEVfVUlOVCB8IENUTEZMQUdfTVBTQUZFIHwgQ1RMRkxBR19SVywgMCwgc2l6ZW9mKHVf aW50KSwKKyAgICBzeXNjdGxfdmZzX3pmc19hcmNfZnJlZV90YXJnZXQsICJJVSIsCisgICAgIkRl c2lyZWQgbnVtYmVyIG9mIGZyZWUgcGFnZXMgYmVsb3cgd2hpY2ggQVJDIHRyaWdnZXJzIHJlY2xh aW0iKTsKK1NZU0NUTF9QUk9DKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2NhY2hlX3RhcmdldCwK KyAgICBDVExUWVBFX1VJTlQgfCBDVExGTEFHX01QU0FGRSB8IENUTEZMQUdfUlcsIDAsIHNpemVv Zih1X2ludCksCisgICAgc3lzY3RsX3Zmc196ZnNfYXJjX2NhY2hlX3RhcmdldCwgIklVIiwKKyAg ICAiRGVzaXJlZCBudW1iZXIgb2YgZnJlZSBwYWdlcyBiZWxvdyB3aGljaCBBUkMgdHJpZ2dlcnMg Y2FjaGUgcmVjbGFpbSIpOwogCisKK3N0YXRpYyBpbnQKK3N5c2N0bF92ZnNfemZzX2FyY19mcmVl X3RhcmdldChTWVNDVExfSEFORExFUl9BUkdTKQoreworCXVfaW50IHZhbDsKKwlpbnQgZXJyOwor CisJdmFsID0gemZzX2FyY19mcmVlX3RhcmdldDsKKwllcnIgPSBzeXNjdGxfaGFuZGxlX2ludChv aWRwLCAmdmFsLCAwLCByZXEpOworCWlmIChlcnIgIT0gMCB8fCByZXEtPm5ld3B0ciA9PSBOVUxM KQorCQlyZXR1cm4gKGVycik7CisKKwlpZiAodmFsIDwgbWluZnJlZSkKKwkJcmV0dXJuIChFSU5W QUwpOworCWlmICh2YWwgPiBjbnQudl9wYWdlX2NvdW50KQorCQlyZXR1cm4gKEVJTlZBTCk7CisK Kwl6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gdmFsOworCisJcmV0dXJuICgwKTsKK30KKworc3RhdGlj IGludAorc3lzY3RsX3Zmc196ZnNfYXJjX2NhY2hlX3RhcmdldChTWVNDVExfSEFORExFUl9BUkdT KQoreworCXVfaW50IHZhbDsKKwlpbnQgZXJyOworCisJdmFsID0gemZzX2FyY19jYWNoZV90YXJn ZXQ7CisJZXJyID0gc3lzY3RsX2hhbmRsZV9pbnQob2lkcCwgJnZhbCwgMCwgcmVxKTsKKwlpZiAo ZXJyICE9IDAgfHwgcmVxLT5uZXdwdHIgPT0gTlVMTCkKKwkJcmV0dXJuIChlcnIpOworCisJaWYg KHZhbCA8IG1pbmZyZWUpCisJCXJldHVybiAoRUlOVkFMKTsKKwlpZiAodmFsID4gY250LnZfcGFn ZV9jb3VudCkKKwkJcmV0dXJuIChFSU5WQUwpOworCisJemZzX2FyY19jYWNoZV90YXJnZXQgPSB2 YWw7CisKKwlyZXR1cm4gKDApOworfQorI2VuZGlmCisKIC8qCiAgKiBOb3RlIHRoYXQgYnVmZmVy cyBjYW4gYmUgaW4gb25lIG9mIDYgc3RhdGVzOgogICoJQVJDX2Fub24JLSBhbm9ueW1vdXMgKGRp c2N1c3NlZCBiZWxvdykKQEAgLTU5Miw2ICs2ODcsMTMgQEAgc3RhdGljIHZvaWQgYXJjX2V2aWN0 X2dob3N0KGFyY19zdGF0ZV90ICpzdGF0ZSwgdWkKIHN0YXRpYyB2b2lkIGFyY19idWZfd2F0Y2go YXJjX2J1Zl90ICpidWYpOwogI2VuZGlmIC8qIGlsbHVtb3MgKi8KIAorc3RhdGljIHVpbnQ2NF90 IGFyY19jYWNoZV9mcmVlKHZvaWQpOworc3RhdGljIGJvb2xlYW5fdCBhcmNfY2FjaGVfcmVjbGFp bV9uZWVkZWQodWludDY0X3Qgc2l6ZSk7CitzdGF0aWMgYm9vbGVhbl90IGFyY19jYWNoZV9yZWNs YWltKHVpbnQ2NF90IHNpemUsCisgICAgYXJjX2NhY2hlX3JlY2xhaW1fc3RyYXRlZ3lfdCBzdHJh dCk7CitzdGF0aWMgYm9vbGVhbl90IGFyY19jYWNoZV9yZWNsYWltX3N0cmF0KGttZW1fY2FjaGVf dCAqY2FjaGUsIHVpbnQ2NF90IHNpemUsCisgICAgYXJjX2NhY2hlX3JlY2xhaW1fc3RyYXRlZ3lf dCBzdHJhdCk7CisKIHN0YXRpYyBib29sZWFuX3QgbDJhcmNfd3JpdGVfZWxpZ2libGUodWludDY0 X3Qgc3BhX2d1aWQsIGFyY19idWZfaGRyX3QgKmFiKTsKIAogI2RlZmluZQlHSE9TVF9TVEFURShz dGF0ZSkJXApAQCAtMjQyMSw2ICsyNTIzLDcgQEAgYXJjX2ZsdXNoKHNwYV90ICpzcGEpCiB2b2lk CiBhcmNfc2hyaW5rKHZvaWQpCiB7CisKIAlpZiAoYXJjX2MgPiBhcmNfY19taW4pIHsKIAkJdWlu dDY0X3QgdG9fZnJlZTsKIApAQCAtMjQyOSw2ICsyNTMyLDkgQEAgYXJjX3Nocmluayh2b2lkKQog I2Vsc2UKIAkJdG9fZnJlZSA9IGFyY19jID4+IGFyY19zaHJpbmtfc2hpZnQ7CiAjZW5kaWYKKwkJ RFRSQUNFX1BST0JFNChhcmNfX3NocmluaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRfdCwKKwkJ CWFyY19jX21pbiwgdWludDY0X3QsIGFyY19wLCB1aW50NjRfdCwgdG9fZnJlZSk7CisKIAkJaWYg KGFyY19jID4gYXJjX2NfbWluICsgdG9fZnJlZSkKIAkJCWF0b21pY19hZGRfNjQoJmFyY19jLCAt dG9fZnJlZSk7CiAJCWVsc2UKQEAgLTI0MzksMTIgKzI1NDUsMTkgQEAgYXJjX3Nocmluayh2b2lk KQogCQkJYXJjX2MgPSBNQVgoYXJjX3NpemUsIGFyY19jX21pbik7CiAJCWlmIChhcmNfcCA+IGFy Y19jKQogCQkJYXJjX3AgPSAoYXJjX2MgPj4gMSk7CisKKwkJRFRSQUNFX1BST0JFMihhcmNfX3No cnVuaywgdWludDY0X3QsIGFyY19jLCB1aW50NjRfdCwKKwkJCWFyY19wKTsKKwogCQlBU1NFUlQo YXJjX2MgPj0gYXJjX2NfbWluKTsKIAkJQVNTRVJUKChpbnQ2NF90KWFyY19wID49IDApOwogCX0K IAotCWlmIChhcmNfc2l6ZSA+IGFyY19jKQorCWlmIChhcmNfc2l6ZSA+IGFyY19jKSB7CisJCURU UkFDRV9QUk9CRTIoYXJjX19zaHJpbmtfYWRqdXN0LCB1aW50NjRfdCwgYXJjX3NpemUsCisJCQl1 aW50NjRfdCwgYXJjX2MpOwogCQlhcmNfYWRqdXN0KCk7CisJfQogfQogCiBzdGF0aWMgaW50IG5l ZWRmcmVlID0gMDsKQEAgLTI0NTQsMTYgKzI1NjcsMjYgQEAgYXJjX3JlY2xhaW1fbmVlZGVkKHZv aWQpCiB7CiAKICNpZmRlZiBfS0VSTkVMCisJaWYgKGFyY19zaXplIDw9IGFyY19jX21pbikgewor CQlEVFJBQ0VfUFJPQkUyKGFyY19fcmVjbGFpbV9taW4sIHVpbnQ2NF90LCBhcmNfc2l6ZSwKKwkJ ICAgIHVpbnQ2NF90LCBhcmNfY19taW4pOworCQlyZXR1cm4gKDApOworCX0KIAotCWlmIChuZWVk ZnJlZSkKKwlpZiAobmVlZGZyZWUpIHsKKwkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9uZWVk ZnJlZSk7CiAJCXJldHVybiAoMSk7CisJfQogCiAJLyoKIAkgKiBDb29wZXJhdGUgd2l0aCBwYWdl ZGFlbW9uIHdoZW4gaXQncyB0aW1lIGZvciBpdCB0byBzY2FuCiAJICogYW5kIHJlY2xhaW0gc29t ZSBwYWdlcy4KIAkgKi8KLQlpZiAodm1fcGFnaW5nX25lZWRlZCgpKQorCWlmIChmcmVlbWVtIDwg emZzX2FyY19mcmVlX3RhcmdldCkgeworCQlEVFJBQ0VfUFJPQkUyKGFyY19fcmVjbGFpbV9mcmVl bWVtLCB1aW50NjRfdCwKKwkJICAgIGZyZWVtZW0sIHVpbnQ2NF90LCB6ZnNfYXJjX2ZyZWVfdGFy Z2V0KTsKIAkJcmV0dXJuICgxKTsKKwl9CiAKICNpZmRlZiBzdW4KIAkvKgpAQCAtMjQ5MSw4ICsy NjE0LDE5IEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogCWlmIChhdmFpbHJtZW0gPCBzd2Fw ZnNfbWluZnJlZSArIHN3YXBmc19yZXNlcnZlICsgZXh0cmEpCiAJCXJldHVybiAoMSk7CiAKLSNp ZiBkZWZpbmVkKF9faTM4NikKIAkvKgorCSAqIENoZWNrIHRoYXQgd2UgaGF2ZSBlbm91Z2ggYXZh aWxybWVtIHRoYXQgbWVtb3J5IGxvY2tpbmcgKGUuZy4sIHZpYQorCSAqIG1sb2NrKDNDKSBvciBt ZW1jbnRsKDIpKSBjYW4gc3RpbGwgc3VjY2VlZC4gIChwYWdlc19wcF9tYXhpbXVtCisJICogc3Rv cmVzIHRoZSBudW1iZXIgb2YgcGFnZXMgdGhhdCBjYW5ub3QgYmUgbG9ja2VkOyB3aGVuIGF2YWls cm1lbQorCSAqIGRyb3BzIGJlbG93IHBhZ2VzX3BwX21heGltdW0sIHBhZ2UgbG9ja2luZyBtZWNo YW5pc21zIHN1Y2ggYXMKKwkgKiBwYWdlX3BwX2xvY2soKSB3aWxsIGZhaWwuKQorCSAqLworCWlm IChhdmFpbHJtZW0gPD0gcGFnZXNfcHBfbWF4aW11bSkKKwkJcmV0dXJuICgxKTsKKworI2VuZGlm CS8qIHN1biAqLworI2lmIGRlZmluZWQoX19pMzg2KSB8fCAhZGVmaW5lZChVTUFfTURfU01BTExf QUxMT0MpCisJLyoKIAkgKiBJZiB3ZSdyZSBvbiBhbiBpMzg2IHBsYXRmb3JtLCBpdCdzIHBvc3Np YmxlIHRoYXQgd2UnbGwgZXhoYXVzdCB0aGUKIAkgKiBrZXJuZWwgaGVhcCBzcGFjZSBiZWZvcmUg d2UgZXZlciBydW4gb3V0IG9mIGF2YWlsYWJsZSBwaHlzaWNhbAogCSAqIG1lbW9yeS4gIE1vc3Qg Y2hlY2tzIG9mIHRoZSBzaXplIG9mIHRoZSBoZWFwX2FyZWEgY29tcGFyZSBhZ2FpbnN0CkBAIC0y NTAzLDI2ICsyNjM3LDQzIEBAIGFyY19yZWNsYWltX25lZWRlZCh2b2lkKQogCSAqIGhlYXAgaXMg YWxsb2NhdGVkLiAgKE9yLCBpbiB0aGUgY2FsY3VsYXRpb24sIGlmIGxlc3MgdGhhbiAxLzR0aCBp cwogCSAqIGZyZWUpCiAJICovCi0JaWYgKGJ0b3Aodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1f RlJFRSkpIDwKLQkgICAgKGJ0b3Aodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZN RU1fQUxMT0MpKSA+PiAyKSkKKwlpZiAodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkg PAorCSAgICAodm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSB8IFZNRU1fQUxMT0MpID4+ IDIpKSB7CisJCURUUkFDRV9QUk9CRTIoYXJjX19yZWNsYWltX3VzZWQsIHVpbnQ2NF90LAorCQkg ICAgdm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSksIHVpbnQ2NF90LAorCQkgICAgKHZt ZW1fc2l6ZShoZWFwX2FyZW5hLCBWTUVNX0ZSRUUgfCBWTUVNX0FMTE9DKSkgPj4gMik7CiAJCXJl dHVybiAoMSk7CisJfQogI2VuZGlmCi0jZWxzZQkvKiAhc3VuICovCi0JaWYgKGttZW1fdXNlZCgp ID4gKGttZW1fc2l6ZSgpICogMykgLyA0KQorI2lmZGVmIHN1bgorCS8qCisJICogSWYgemlvIGRh dGEgcGFnZXMgYXJlIGJlaW5nIGFsbG9jYXRlZCBvdXQgb2YgYSBzZXBhcmF0ZSBoZWFwIHNlZ21l bnQsCisJICogdGhlbiBlbmZvcmNlIHRoYXQgdGhlIHNpemUgb2YgYXZhaWxhYmxlIHZtZW0gZm9y IHRoaXMgYXJlbmEgcmVtYWlucworCSAqIGFib3ZlIGFib3V0IDEvMTZ0aCBmcmVlLgorCSAqCisJ ICogTm90ZTogVGhlIDEvMTZ0aCBhcmVuYSBmcmVlIHJlcXVpcmVtZW50IHdhcyBwdXQgaW4gcGxh Y2UKKwkgKiB0byBhZ2dyZXNzaXZlbHkgZXZpY3QgbWVtb3J5IGZyb20gdGhlIGFyYyBpbiBvcmRl ciB0byBhdm9pZAorCSAqIG1lbW9yeSBmcmFnbWVudGF0aW9uIGlzc3Vlcy4KKwkgKi8KKwlpZiAo emlvX2FyZW5hICE9IE5VTEwgJiYKKwkgICAgdm1lbV9zaXplKHppb19hcmVuYSwgVk1FTV9GUkVF KSA8CisJICAgICh2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0FMTE9DKSA+PiA0KSkKIAkJcmV0 dXJuICgxKTsKICNlbmRpZgkvKiBzdW4gKi8KLQotI2Vsc2UKKyNlbHNlCS8qIF9LRVJORUwgKi8K IAlpZiAoc3BhX2dldF9yYW5kb20oMTAwKSA9PSAwKQogCQlyZXR1cm4gKDEpOwotI2VuZGlmCisj ZW5kaWYJLyogX0tFUk5FTCAqLworCURUUkFDRV9QUk9CRShhcmNfX3JlY2xhaW1fbm8pOworCiAJ cmV0dXJuICgwKTsKIH0KIAogZXh0ZXJuIGttZW1fY2FjaGVfdAkqemlvX2J1Zl9jYWNoZVtdOwog ZXh0ZXJuIGttZW1fY2FjaGVfdAkqemlvX2RhdGFfYnVmX2NhY2hlW107CitleHRlcm4ga21lbV9j YWNoZV90CSpyYW5nZV9zZWdfY2FjaGU7CiAKLXN0YXRpYyB2b2lkCitzdGF0aWMgdm9pZCBfX25v aW5saW5lCiBhcmNfa21lbV9yZWFwX25vdyhhcmNfcmVjbGFpbV9zdHJhdGVneV90IHN0cmF0KQog ewogCXNpemVfdAkJCWk7CkBAIC0yNTI5LDYgKzI2ODAsNyBAQCBhcmNfa21lbV9yZWFwX25vdyhh cmNfcmVjbGFpbV9zdHJhdGVneV90IHN0cmF0KQogCWttZW1fY2FjaGVfdAkJKnByZXZfY2FjaGUg PSBOVUxMOwogCWttZW1fY2FjaGVfdAkJKnByZXZfZGF0YV9jYWNoZSA9IE5VTEw7CiAKKwlEVFJB Q0VfUFJPQkUoYXJjX19rbWVtX3JlYXBfc3RhcnQpOwogI2lmZGVmIF9LRVJORUwKIAlpZiAoYXJj X21ldGFfdXNlZCA+PSBhcmNfbWV0YV9saW1pdCkgewogCQkvKgpAQCAtMjUzNyw3ICsyNjg5LDcg QEAgYXJjX2ttZW1fcmVhcF9ub3coYXJjX3JlY2xhaW1fc3RyYXRlZ3lfdCBzdHJhdCkKIAkJICov CiAJCWRubGNfcmVkdWNlX2NhY2hlKCh2b2lkICopKHVpbnRwdHJfdClhcmNfcmVkdWNlX2RubGNf cGVyY2VudCk7CiAJfQotI2lmIGRlZmluZWQoX19pMzg2KQorI2lmIGRlZmluZWQoX19pMzg2KSB8 fCAhZGVmaW5lZChVTUFfTURfU01BTExfQUxMT0MpCiAJLyoKIAkgKiBSZWNsYWltIHVudXNlZCBt ZW1vcnkgZnJvbSBhbGwga21lbSBjYWNoZXMuCiAJICovCkBAIC0yNTUyLDIwICsyNzA0LDEzMSBA QCBhcmNfa21lbV9yZWFwX25vdyhhcmNfcmVjbGFpbV9zdHJhdGVneV90IHN0cmF0KQogCWlmIChz dHJhdCA9PSBBUkNfUkVDTEFJTV9BR0dSKQogCQlhcmNfc2hyaW5rKCk7CiAKKwkodm9pZCkgYXJj X2NhY2hlX3JlY2xhaW0oMCwgQVJDX0NBQ0hFX1JFQ0xBSU1fRk9SQ0UpOworCisjaWZkZWYgc3Vu CisJLyoKKwkgKiBBc2sgdGhlIHZtZW0gYXJlYW5hIHRvIHJlY2xhaW0gdW51c2VkIG1lbW9yeSBm cm9tIGl0cworCSAqIHF1YW50dW0gY2FjaGVzLgorCSAqLworCWlmICh6aW9fYXJlbmEgIT0gTlVM TCAmJiBzdHJhdCA9PSBBUkNfUkVDTEFJTV9BR0dSKQorCQl2bWVtX3FjYWNoZV9yZWFwKHppb19h cmVuYSk7CisjZW5kaWYKK291dDoKKwlEVFJBQ0VfUFJPQkUoYXJjX19rbWVtX3JlYXBfZW5kKTsK K30KKworCitzdGF0aWMgYm9vbGVhbl90CithcmNfY2FjaGVfcmVjbGFpbV9uZWVkZWQodWludDY0 X3Qgc2l6ZSkKK3sKKworCWlmICh6ZnNfYXJjX2NhY2hlX3RhcmdldCAmJiBmcmVlbWVtIDwgemZz X2FyY19jYWNoZV90YXJnZXQgKyBidG9wKHNpemUpKSB7CisJCURUUkFDRV9QUk9CRTEoYXJjX2Nh Y2hlX3JlY2xhaW1fbmVlZGVkLCBpbnQsIEJfVFJVRSk7CisJCXJldHVybiAoQl9UUlVFKTsKKwl9 CisKKwlEVFJBQ0VfUFJPQkUxKGFyY19jYWNoZV9yZWNsYWltX25lZWRlZCwgaW50LCBCX0ZBTFNF KTsKKwlyZXR1cm4gKEJfRkFMU0UpOworfQorCitzdGF0aWMgYm9vbGVhbl90CithcmNfY2FjaGVf cmVjbGFpbV9zdHJhdChrbWVtX2NhY2hlX3QgKmNhY2hlLCB1aW50NjRfdCBzaXplLAorICAgIGFy Y19jYWNoZV9yZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCit7CisKKwlzd2l0Y2goc3RyYXQpIHsK KwljYXNlIEFSQ19DQUNIRV9SRUNMQUlNX05PVzoKKwljYXNlIEFSQ19DQUNIRV9SRUNMQUlNX0ZP UkNFOgorCQlrbWVtX2NhY2hlX3JlYXBfbm93KGNhY2hlKTsKKwkJaWYgKHpmc19hcmNfY2FjaGVf cGFydGlhbCAmJiBzdHJhdCAhPSBBUkNfQ0FDSEVfUkVDTEFJTV9GT1JDRSAmJgorCQkgICAgIWFy Y19jYWNoZV9yZWNsYWltX25lZWRlZChzaXplKSkgeworCQkJcmV0dXJuIChCX1RSVUUpOworCQl9 CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWttZW1fY2FjaGVfcmVhcChjYWNoZSwgemZzX2FyY19j YWNoZV9mcmVlX21heCk7CisJfQorCisJcmV0dXJuIChCX0ZBTFNFKTsKK30KKworc3RhdGljIGJv b2xlYW5fdAorYXJjX2NhY2hlX3JlY2xhaW0odWludDY0X3Qgc2l6ZSwgYXJjX2NhY2hlX3JlY2xh aW1fc3RyYXRlZ3lfdCBzdHJhdCkKK3sKKwlpbnQgaTsKKwljbG9ja190IG5vdzsKKwlrbWVtX2Nh Y2hlX3QgKnByZXZfY2FjaGUsICpwcmV2X2RhdGFfY2FjaGU7CisKKwlpZiAoc3RyYXQgIT0gQVJD X0NBQ0hFX1JFQ0xBSU1fRk9SQ0UpIHsKKwkJbm93ID0gZGRpX2dldF9sYm9sdCgpOworCQlEVFJB Q0VfUFJPQkUzKGFyY19jYWNoZV9yZWNsYWltX3Rlc3QsIGludCwgc3RyYXQsIGludDY0X3QsIG5v dywKKwkJICAgIGludDY0X3QsIGFyY19jYWNoZV9yZWNsYWltX2xhc3QpOworCQlpZiAobm93IC0g YXJjX2NhY2hlX3JlY2xhaW1fbGFzdCA8ICh6ZnNfYXJjX2NhY2hlX3BlcmlvZCAqIGh6KSkKKwkJ CXJldHVybiAoQl9GQUxTRSk7CisJfQorCisJRFRSQUNFX1BST0JFMShhcmNfY2FjaGVfcmVjbGFp bSwgaW50LCBzdHJhdCk7CisKIAlmb3IgKGkgPSAwOyBpIDwgU1BBX01BWEJMT0NLU0laRSA+PiBT UEFfTUlOQkxPQ0tTSElGVDsgaSsrKSB7CiAJCWlmICh6aW9fYnVmX2NhY2hlW2ldICE9IHByZXZf Y2FjaGUpIHsKIAkJCXByZXZfY2FjaGUgPSB6aW9fYnVmX2NhY2hlW2ldOwotCQkJa21lbV9jYWNo ZV9yZWFwX25vdyh6aW9fYnVmX2NhY2hlW2ldKTsKKwkJCWlmIChhcmNfY2FjaGVfcmVjbGFpbV9z dHJhdCh6aW9fYnVmX2NhY2hlW2ldLCBzaXplLAorCQkJICAgIHN0cmF0KSkgeworCQkJCXJldHVy biAoQl9UUlVFKTsKKwkJCX0KKwogCQl9CiAJCWlmICh6aW9fZGF0YV9idWZfY2FjaGVbaV0gIT0g cHJldl9kYXRhX2NhY2hlKSB7CiAJCQlwcmV2X2RhdGFfY2FjaGUgPSB6aW9fZGF0YV9idWZfY2Fj aGVbaV07Ci0JCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19kYXRhX2J1Zl9jYWNoZVtpXSk7CisJ CQlpZiAoYXJjX2NhY2hlX3JlY2xhaW1fc3RyYXQoemlvX2RhdGFfYnVmX2NhY2hlW2ldLAorCQkJ ICAgIHNpemUsIHN0cmF0KSkKKwkJCQlyZXR1cm4gKEJfVFJVRSk7CiAJCX0KIAl9Ci0Ja21lbV9j YWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOwotCWttZW1fY2FjaGVfcmVhcF9ub3coaGRyX2NhY2hl KTsKKwlpZiAoYXJjX2NhY2hlX3JlY2xhaW1fc3RyYXQocmFuZ2Vfc2VnX2NhY2hlLCBzaXplLCBz dHJhdCkpCisJCXJldHVybiAoQl9UUlVFKTsKKworCWlmIChhcmNfY2FjaGVfcmVjbGFpbV9zdHJh dChidWZfY2FjaGUsIHNpemUsIHN0cmF0KSkKKwkJcmV0dXJuIChCX1RSVUUpOworCisJYXJjX2Nh Y2hlX3JlY2xhaW1fc3RyYXQoaGRyX2NhY2hlLCBzaXplLCBzdHJhdCk7CisKKwlhcmNfY2FjaGVf cmVjbGFpbV9sYXN0ID0gZGRpX2dldF9sYm9sdCgpOworCisJaWYgKGFyY19jYWNoZV9yZWNsYWlt X25lZWRlZChzaXplKSkKKwkJcmV0dXJuIChCX0ZBTFNFKTsKKworCXJldHVybiAoQl9UUlVFKTsK IH0KIAorc3RhdGljIHVpbnQ2NF90CithcmNfY2FjaGVfZnJlZSh2b2lkKQoreworCWludCBpOwor CXVpbnQ2NF90IGNhY2hlZnJlZTsKKwlrbWVtX2NhY2hlX3QgKnByZXZfY2FjaGUsICpwcmV2X2Rh dGFfY2FjaGU7CisKKwljYWNoZWZyZWUgPSBrbWVtX2NhY2hlX2ZyZWVfc2l6ZShidWZfY2FjaGUp ICsKKwkgICAga21lbV9jYWNoZV9mcmVlX3NpemUoaGRyX2NhY2hlKTsKKworCXByZXZfY2FjaGUg PSBOVUxMOworCXByZXZfZGF0YV9jYWNoZSA9IE5VTEw7CisKKyAgICAgICAgZm9yIChpID0gMDsg aSA8IFNQQV9NQVhCTE9DS1NJWkUgPj4gU1BBX01JTkJMT0NLU0hJRlQ7IGkrKykgeworICAgICAg ICAgICAgICAgIGlmICh6aW9fYnVmX2NhY2hlW2ldICE9IHByZXZfY2FjaGUpIHsKKyAgICAgICAg ICAgICAgICAgICAgICAgIHByZXZfY2FjaGUgPSB6aW9fYnVmX2NhY2hlW2ldOworICAgICAgICAg ICAgICAgICAgICAgICAgY2FjaGVmcmVlICs9IGttZW1fY2FjaGVfZnJlZV9zaXplKHppb19idWZf Y2FjaGVbaV0pOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICBpZiAoemlvX2Rh dGFfYnVmX2NhY2hlW2ldICE9IHByZXZfZGF0YV9jYWNoZSkgeworICAgICAgICAgICAgICAgICAg ICAgICAgcHJldl9kYXRhX2NhY2hlID0gemlvX2RhdGFfYnVmX2NhY2hlW2ldOworICAgICAgICAg ICAgICAgICAgICAgICAgY2FjaGVmcmVlICs9IGttZW1fY2FjaGVfZnJlZV9zaXplKHppb19kYXRh X2J1Zl9jYWNoZVtpXSk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICB9CisKKwlyZXR1cm4g KGNhY2hlZnJlZSk7Cit9CisKIHN0YXRpYyB2b2lkCiBhcmNfcmVjbGFpbV90aHJlYWQodm9pZCAq ZHVtbXkgX191bnVzZWQpCiB7CkBAIC0yNTc3LDEwICsyODQwLDM2IEBAIGFyY19yZWNsYWltX3Ro cmVhZCh2b2lkICpkdW1teSBfX3VudXNlZCkKIAogCW11dGV4X2VudGVyKCZhcmNfcmVjbGFpbV90 aHJfbG9jayk7CiAJd2hpbGUgKGFyY190aHJlYWRfZXhpdCA9PSAwKSB7CisJCURUUkFDRV9QUk9C RShhcmNfX3JlY2xhaW1fdGhyZWFkKTsKKwkJLyoKKwkJICogQXMgZnJlZSBpdGVtcyBpbiBvdXIg Y2FjaGVzIGNhbiB0YWtlIHVwIHNpZ25pZmljYW50IFJBTQorCQkgKiBwb3NzaWJseSBpbiBpbmZy ZXF1ZW50bHkgdXNlZCB6b25lcyB3ZSB0cmlnZ2VyIGEgY2FjaGUKKwkJICogcmVjbGFpbSBpZjoK KwkJICogMS4gV2UncmUgYmVsb3cgemZzX2FyY19jYWNoZV90YXJnZXQgdGhyZXNob2xkCisJCSAq IDIuIEl0cyBiZWVuIHpmc19hcmNfY2FjaGVfZnJlZV9wZXJpb2Qgc2Vjb25kcyBzaW5jZSB0aGUK KwkJICogICAgbGFzdCBjYWNoZSByZWNsYWltLgorCQkgKi8KKwkJaWYgKGFyY19jYWNoZV9yZWNs YWltX25lZWRlZCgwKSkgeworCQkJKHZvaWQpIGFyY19jYWNoZV9yZWNsYWltKDAsIEFSQ19DQUNI RV9SRUNMQUlNX05PVyk7CisJCX0gZWxzZSB7CisJCQljbG9ja190IG5vdzsKKworCQkJbm93ID0g ZGRpX2dldF9sYm9sdCgpOworCQkJRFRSQUNFX1BST0JFMihhcmNfX3JlY2xhaW1fY2hlY2ssIGlu dDY0X3QsIG5vdywKKwkJCQlpbnQ2NF90LCBhcmNfY2FjaGVfcmVjbGFpbV9sYXN0KTsKKwkJCWlm IChub3cgLSBhcmNfY2FjaGVfcmVjbGFpbV9sYXN0ID4KKwkJCSAgICAoemZzX2FyY19jYWNoZV9m cmVlX3BlcmlvZCAqIGh6KSkgeworCQkJCSh2b2lkKSBhcmNfY2FjaGVfcmVjbGFpbSgwLAorCQkJ CSAgICBBUkNfQ0FDSEVfUkVDTEFJTV9TSVpFKTsKKwkJCX0KKwkJfQorCiAJCWlmIChhcmNfcmVj bGFpbV9uZWVkZWQoKSkgewotCisJCQlEVFJBQ0VfUFJPQkUxKGFyY19fY2FjaGVzX2ZyZWUsIHVp bnQ2NF90LAorCQkJICAgIGFyY19jYWNoZV9mcmVlKCkpOwogCQkJaWYgKGFyY19ub19ncm93KSB7 CiAJCQkJaWYgKGxhc3RfcmVjbGFpbSA9PSBBUkNfUkVDTEFJTV9DT05TKSB7CisJCQkJCURUUkFD RV9QUk9CRShhcmNfX3JlY2xhaW1fYWdncl9ub19ncm93KTsKIAkJCQkJbGFzdF9yZWNsYWltID0g QVJDX1JFQ0xBSU1fQUdHUjsKIAkJCQl9IGVsc2UgewogCQkJCQlsYXN0X3JlY2xhaW0gPSBBUkNf UkVDTEFJTV9DT05TOwpAQCAtMjU4OCw2ICsyODc3LDcgQEAgYXJjX3JlY2xhaW1fdGhyZWFkKHZv aWQgKmR1bW15IF9fdW51c2VkKQogCQkJfSBlbHNlIHsKIAkJCQlhcmNfbm9fZ3JvdyA9IFRSVUU7 CiAJCQkJbGFzdF9yZWNsYWltID0gQVJDX1JFQ0xBSU1fQUdHUjsKKwkJCQlEVFJBQ0VfUFJPQkUo YXJjX19yZWNsYWltX2FnZ3IpOwogCQkJCW1lbWJhcl9wcm9kdWNlcigpOwogCQkJfQogCkBAIC0y NjAyLDYgKzI4OTIsNyBAQCBhcmNfcmVjbGFpbV90aHJlYWQodm9pZCAqZHVtbXkgX191bnVzZWQp CiAJCQkJICovCiAJCQkJYXJjX25vX2dyb3cgPSBUUlVFOwogCQkJCWxhc3RfcmVjbGFpbSA9IEFS Q19SRUNMQUlNX0FHR1I7CisJCQkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV9hZ2dyX25lZWRm cmVlKTsKIAkJCX0KIAkJCWFyY19rbWVtX3JlYXBfbm93KGxhc3RfcmVjbGFpbSk7CiAJCQlhcmNf d2FybSA9IEJfVFJVRTsKQEAgLTI2MTgsNiArMjkwOSw3IEBAIGFyY19yZWNsYWltX3RocmVhZCh2 b2lkICpkdW1teSBfX3VudXNlZCkKICNpZmRlZiBfS0VSTkVMCiAJCWlmIChuZWVkZnJlZSkgewog CQkJbmVlZGZyZWUgPSAwOworCQkJRFRSQUNFX1BST0JFKGFyY19fY2xlYXJfbmVlZGZyZWUpOwog CQkJd2FrZXVwKCZuZWVkZnJlZSk7CiAJCX0KICNlbmRpZgpAQCAtMjY5Miw2ICsyOTg0LDcgQEAg YXJjX2FkYXB0KGludCBieXRlcywgYXJjX3N0YXRlX3QgKnN0YXRlKQogCSAqIGNhY2hlIHNpemUs IGluY3JlbWVudCB0aGUgdGFyZ2V0IGNhY2hlIHNpemUKIAkgKi8KIAlpZiAoYXJjX3NpemUgPiBh cmNfYyAtICgyVUxMIDw8IFNQQV9NQVhCTE9DS1NISUZUKSkgeworCQlEVFJBQ0VfUFJPQkUxKGFy Y19faW5jX2FkYXB0LCBpbnQsIGJ5dGVzKTsKIAkJYXRvbWljX2FkZF82NCgmYXJjX2MsIChpbnQ2 NF90KWJ5dGVzKTsKIAkJaWYgKGFyY19jID4gYXJjX2NfbWF4KQogCQkJYXJjX2MgPSBhcmNfY19t YXg7CkBAIC0yNzEzLDIwICszMDA2LDYgQEAgYXJjX2V2aWN0X25lZWRlZChhcmNfYnVmX2NvbnRl bnRzX3QgdHlwZSkKIAlpZiAodHlwZSA9PSBBUkNfQlVGQ19NRVRBREFUQSAmJiBhcmNfbWV0YV91 c2VkID49IGFyY19tZXRhX2xpbWl0KQogCQlyZXR1cm4gKDEpOwogCi0jaWZkZWYgc3VuCi0jaWZk ZWYgX0tFUk5FTAotCS8qCi0JICogSWYgemlvIGRhdGEgcGFnZXMgYXJlIGJlaW5nIGFsbG9jYXRl ZCBvdXQgb2YgYSBzZXBhcmF0ZSBoZWFwIHNlZ21lbnQsCi0JICogdGhlbiBlbmZvcmNlIHRoYXQg dGhlIHNpemUgb2YgYXZhaWxhYmxlIHZtZW0gZm9yIHRoaXMgYXJlYSByZW1haW5zCi0JICogYWJv dmUgYWJvdXQgMS8zMm5kIGZyZWUuCi0JICovCi0JaWYgKHR5cGUgPT0gQVJDX0JVRkNfREFUQSAm JiB6aW9fYXJlbmEgIT0gTlVMTCAmJgotCSAgICB2bWVtX3NpemUoemlvX2FyZW5hLCBWTUVNX0ZS RUUpIDwKLQkgICAgKHZtZW1fc2l6ZSh6aW9fYXJlbmEsIFZNRU1fQUxMT0MpID4+IDUpKQotCQly ZXR1cm4gKDEpOwotI2VuZGlmCi0jZW5kaWYJLyogc3VuICovCi0KIAlpZiAoYXJjX3JlY2xhaW1f bmVlZGVkKCkpCiAJCXJldHVybiAoMSk7CiAKQEAgLTI3NjMsNiArMzA0Miw5IEBAIGFyY19nZXRf ZGF0YV9idWYoYXJjX2J1Zl90ICpidWYpCiAJdWludDY0X3QJCXNpemUgPSBidWYtPmJfaGRyLT5i X3NpemU7CiAJYXJjX2J1Zl9jb250ZW50c190CXR5cGUgPSBidWYtPmJfaGRyLT5iX3R5cGU7CiAK KwlpZiAoYXJjX2NhY2hlX3JlY2xhaW1fbmVlZGVkKHNpemUpKQorCQkodm9pZCkgYXJjX2NhY2hl X3JlY2xhaW0oc2l6ZSwgQVJDX0NBQ0hFX1JFQ0xBSU1fTk9XKTsKKwogCWFyY19hZGFwdChzaXpl LCBzdGF0ZSk7CiAKIAkvKgpAQCAtMzg4NSwyMCArNDE2NywxNiBAQCBzdGF0aWMgaW50CiBhcmNf bWVtb3J5X3Rocm90dGxlKHVpbnQ2NF90IHJlc2VydmUsIHVpbnQ2NF90IHR4ZykKIHsKICNpZmRl ZiBfS0VSTkVMCi0JdWludDY0X3QgYXZhaWxhYmxlX21lbW9yeSA9Ci0JICAgIHB0b2EoKHVpbnRt YXhfdCljbnQudl9mcmVlX2NvdW50ICsgY250LnZfY2FjaGVfY291bnQpOworCXVpbnQ2NF90IGF2 YWlsYWJsZV9tZW1vcnkgPSBwdG9iKGZyZWVtZW0pOwogCXN0YXRpYyB1aW50NjRfdCBwYWdlX2xv YWQgPSAwOwogCXN0YXRpYyB1aW50NjRfdCBsYXN0X3R4ZyA9IDA7CiAKLSNpZmRlZiBzdW4KLSNp ZiBkZWZpbmVkKF9faTM4NikKKyNpZiBkZWZpbmVkKF9faTM4NikgfHwgIWRlZmluZWQoVU1BX01E X1NNQUxMX0FMTE9DKQogCWF2YWlsYWJsZV9tZW1vcnkgPQotCSAgICBNSU4oYXZhaWxhYmxlX21l bW9yeSwgdm1lbV9zaXplKGhlYXBfYXJlbmEsIFZNRU1fRlJFRSkpOworCSAgICBNSU4oYXZhaWxh YmxlX21lbW9yeSwgcHRvYih2bWVtX3NpemUoaGVhcF9hcmVuYSwgVk1FTV9GUkVFKSkpOwogI2Vu ZGlmCi0jZW5kaWYJLyogc3VuICovCiAKLQlpZiAoY250LnZfZnJlZV9jb3VudCArIGNudC52X2Nh Y2hlX2NvdW50ID4KLQkgICAgKHVpbnQ2NF90KXBoeXNtZW0gKiBhcmNfbG90c2ZyZWVfcGVyY2Vu dCAvIDEwMCkKKwlpZiAoZnJlZW1lbSA+ICh1aW50NjRfdClwaHlzbWVtICogYXJjX2xvdHNmcmVl X3BlcmNlbnQgLyAxMDApCiAJCXJldHVybiAoMCk7CiAKIAlpZiAodHhnID4gbGFzdF90eGcpIHsK QEAgLTM5MTEsNyArNDE4OSw3IEBAIGFyY19tZW1vcnlfdGhyb3R0bGUodWludDY0X3QgcmVzZXJ2 ZSwgdWludDY0X3QgdHhnCiAJICogY29udGludWUgdG8gbGV0IHBhZ2Ugd3JpdGVzIG9jY3VyIGFz IHF1aWNrbHkgYXMgcG9zc2libGUuCiAJICovCiAJaWYgKGN1cnByb2MgPT0gcGFnZXByb2MpIHsK LQkJaWYgKHBhZ2VfbG9hZCA+IGF2YWlsYWJsZV9tZW1vcnkgLyA0KQorCQlpZiAocGFnZV9sb2Fk ID4gTUFYKHB0b2IobWluZnJlZSksIGF2YWlsYWJsZV9tZW1vcnkpIC8gNCkKIAkJCXJldHVybiAo U0VUX0VSUk9SKEVSRVNUQVJUKSk7CiAJCS8qIE5vdGU6IHJlc2VydmUgaXMgaW5mbGF0ZWQsIHNv IHdlIGRlZmxhdGUgKi8KIAkJcGFnZV9sb2FkICs9IHJlc2VydmUgLyA4OwpAQCAtMzkzOSw4ICs0 MjE3LDEwIEBAIGFyY190ZW1wcmVzZXJ2ZV9zcGFjZSh1aW50NjRfdCByZXNlcnZlLCB1aW50NjRf dCB0CiAJaW50IGVycm9yOwogCXVpbnQ2NF90IGFub25fc2l6ZTsKIAotCWlmIChyZXNlcnZlID4g YXJjX2MvNCAmJiAhYXJjX25vX2dyb3cpCisJaWYgKHJlc2VydmUgPiBhcmNfYy80ICYmICFhcmNf bm9fZ3JvdykgewogCQlhcmNfYyA9IE1JTihhcmNfY19tYXgsIHJlc2VydmUgKiA0KTsKKwkJRFRS QUNFX1BST0JFMShhcmNfX3NldF9yZXNlcnZlLCB1aW50NjRfdCwgYXJjX2MpOworCX0KIAlpZiAo cmVzZXJ2ZSA+IGFyY19jKQogCQlyZXR1cm4gKFNFVF9FUlJPUihFTk9NRU0pKTsKIApAQCAtMzk5 NCw2ICs0Mjc0LDcgQEAgYXJjX2xvd21lbSh2b2lkICphcmcgX191bnVzZWQsIGludCBob3d0byBf X3VudXNlZCkKIAltdXRleF9lbnRlcigmYXJjX2xvd21lbV9sb2NrKTsKIAltdXRleF9lbnRlcigm YXJjX3JlY2xhaW1fdGhyX2xvY2spOwogCW5lZWRmcmVlID0gMTsKKwlEVFJBQ0VfUFJPQkUoYXJj X19uZWVkZnJlZSk7CiAJY3Zfc2lnbmFsKCZhcmNfcmVjbGFpbV90aHJfY3YpOwogCiAJLyoKSW5k ZXg6IHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvcmFuZ2Vf dHJlZS5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2Nv bW1vbi9mcy96ZnMvcmFuZ2VfdHJlZS5jCShyZXZpc2lvbiAyNzIwMDUpCisrKyBzeXMvY2RkbC9j b250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3JhbmdlX3RyZWUuYwkod29ya2lu ZyBjb3B5KQpAQCAtMzMsNyArMzMsNyBAQAogI2luY2x1ZGUgPHN5cy96aW8uaD4KICNpbmNsdWRl IDxzeXMvcmFuZ2VfdHJlZS5oPgogCi1zdGF0aWMga21lbV9jYWNoZV90ICpyYW5nZV9zZWdfY2Fj aGU7CitrbWVtX2NhY2hlX3QgKnJhbmdlX3NlZ19jYWNoZTsKIAogdm9pZAogcmFuZ2VfdHJlZV9p bml0KHZvaWQpCkluZGV4OiBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24v ZnMvemZzL3ZkZXZfcXVldWUuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5z b2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3ZkZXZfcXVldWUuYwkocmV2aXNpb24gMjcyMDA1KQor Kysgc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy92ZGV2X3F1 ZXVlLmMJKHdvcmtpbmcgY29weSkKQEAgLTMxMiw2ICszMTIsOCBAQCB2ZGV2X3F1ZXVlX2lvX2Fk ZCh2ZGV2X3F1ZXVlX3QgKnZxLCB6aW9fdCAqemlvKQogCUFTU0VSVChNVVRFWF9IRUxEKCZ2cS0+ dnFfbG9jaykpOwogCUFTU0VSVDNVKHppby0+aW9fcHJpb3JpdHksIDwsIFpJT19QUklPUklUWV9O VU1fUVVFVUVBQkxFKTsKIAlhdmxfYWRkKCZ2cS0+dnFfY2xhc3NbemlvLT5pb19wcmlvcml0eV0u dnFjX3F1ZXVlZF90cmVlLCB6aW8pOworCURUUkFDRV9QUk9CRTModmRldl9xdWV1ZSwgdmRldl9x dWV1ZV90ICosIHZxLCB6aW9fdCAqLCB6aW8sIHVpbnQ2NF90LAorCSAgICBhdmxfbnVtbm9kZXMo JnZxLT52cV9jbGFzc1t6aW8tPmlvX3ByaW9yaXR5XS52cWNfcXVldWVkX3RyZWUpKTsKIAogI2lm ZGVmIGlsbHVtb3MKIAltdXRleF9lbnRlcigmc3BhLT5zcGFfaW9rc3RhdF9sb2NrKTsKSW5kZXg6 IHN5cy92bS91bWEuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvdm0vdW1hLmgJKHJldmlzaW9uIDI3MjAw NSkKKysrIHN5cy92bS91bWEuaAkod29ya2luZyBjb3B5KQpAQCAtNjM2LDYgKzYzNiwxNyBAQCBp bnQgdW1hX3pvbmVfZXhoYXVzdGVkKHVtYV96b25lX3Qgem9uZSk7CiBpbnQgdW1hX3pvbmVfZXho YXVzdGVkX25vbG9jayh1bWFfem9uZV90IHpvbmUpOwogCiAvKgorICogVXNlZCB0byBkZXRlcm1p bmUgdGhlIGFtb3VudCBvZiBtZW1vcnkgY29uc3VtZWQgYnkgYSB6b25lJ3MgZnJlZSBzcGFjZS4K KyAqCisgKiBBcmd1bWVudHM6CisgKgl6b25lCVRoZSB6b25lIHRvIGRldGVybWluZSB0aGUgZnJl ZSBzcGFjZSBvZi4KKyAqCisgKiBSZXR1cm5zOgorICoJdWludDY0X3QgVGhlIGFtb3VudCBvZiBt ZW1vcnkgY29uc3VtZWQgYnkgdGhlIHpvbmUncyBmcmVlIHNwYWNlLgorICovCit1aW50NjRfdCB1 bWFfem9uZV9mcmVlX3NpemUodW1hX3pvbmVfdCB6b25lKTsKKworLyoKICAqIENvbW1vbiBVTUFf Wk9ORV9QQ1BVIHpvbmVzLgogICovCiBleHRlcm4gdW1hX3pvbmVfdCBwY3B1X3pvbmVfNjQ7Cklu ZGV4OiBzeXMvdm0vdW1hX2NvcmUuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvdm0vdW1hX2NvcmUuYwko cmV2aXNpb24gMjcyMDA1KQorKysgc3lzL3ZtL3VtYV9jb3JlLmMJKHdvcmtpbmcgY29weSkKQEAg LTMzMTIsNiArMzMxMiwzMyBAQCB1bWFfcHJpbnRfem9uZSh1bWFfem9uZV90IHpvbmUpCiAJfQog fQogCit1aW50NjRfdAordW1hX3pvbmVfZnJlZV9zaXplKHVtYV96b25lX3Qgem9uZSkKK3sKKwlp bnQgY3B1OworCXVpbnQ2NF90IGNhY2hlZnJlZTsKKwl1bWFfYnVja2V0X3QgYnVja2V0OworCXVt YV9jYWNoZV90IGNhY2hlOworCisJY2FjaGVmcmVlID0gMDsKKworCVpPTkVfTE9DSyh6b25lKTsK KwlMSVNUX0ZPUkVBQ0goYnVja2V0LCAmem9uZS0+dXpfYnVja2V0cywgdWJfbGluaykKKwkJY2Fj aGVmcmVlICs9ICh1aW50NjRfdClidWNrZXQtPnViX2NudDsKKworCUNQVV9GT1JFQUNIKGNwdSkg eworCQljYWNoZSA9ICZ6b25lLT51el9jcHVbY3B1XTsKKwkJaWYgKGNhY2hlLT51Y19hbGxvY2J1 Y2tldCAhPSBOVUxMKQorCQkJY2FjaGVmcmVlICs9ICh1aW50NjRfdCljYWNoZS0+dWNfYWxsb2Ni dWNrZXQtPnViX2NudDsKKwkJaWYgKGNhY2hlLT51Y19mcmVlYnVja2V0ICE9IE5VTEwpCisJCQlj YWNoZWZyZWUgKz0gKHVpbnQ2NF90KWNhY2hlLT51Y19mcmVlYnVja2V0LT51Yl9jbnQ7CisJfSAK KwljYWNoZWZyZWUgKj0gem9uZS0+dXpfc2l6ZTsKKwlaT05FX1VOTE9DSyh6b25lKTsKKworCXJl dHVybiAoY2FjaGVmcmVlKTsKK30KKwogI2lmZGVmIEREQgogLyoKICAqIEdlbmVyYXRlIHN0YXRp c3RpY3MgYWNyb3NzIGJvdGggdGhlIHpvbmUgYW5kIGl0cyBwZXItY3B1IGNhY2hlJ3MuICBSZXR1 cm4KSW5kZXg6IHN5cy92bS92bV9wYWdlb3V0LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL3ZtL3ZtX3Bh Z2VvdXQuYwkocmV2aXNpb24gMjcyMDA1KQorKysgc3lzL3ZtL3ZtX3BhZ2VvdXQuYwkod29ya2lu ZyBjb3B5KQpAQCAtNzYsNiArNzYsNyBAQAogX19GQlNESUQoIiRGcmVlQlNEJCIpOwogCiAjaW5j bHVkZSAib3B0X3ZtLmgiCisjaW5jbHVkZSAib3B0X2tkdHJhY2UuaCIKICNpbmNsdWRlIDxzeXMv cGFyYW0uaD4KICNpbmNsdWRlIDxzeXMvc3lzdG0uaD4KICNpbmNsdWRlIDxzeXMva2VybmVsLmg+ CkBAIC04OSw2ICs5MCw3IEBAIF9fRkJTRElEKCIkRnJlZUJTRCQiKTsKICNpbmNsdWRlIDxzeXMv cmFjY3QuaD4KICNpbmNsdWRlIDxzeXMvcmVzb3VyY2V2YXIuaD4KICNpbmNsdWRlIDxzeXMvc2No ZWQuaD4KKyNpbmNsdWRlIDxzeXMvc2R0Lmg+CiAjaW5jbHVkZSA8c3lzL3NpZ25hbHZhci5oPgog I2luY2x1ZGUgPHN5cy9zbXAuaD4KICNpbmNsdWRlIDxzeXMvdm5vZGUuaD4KQEAgLTExNSwxMCAr MTE3LDE0IEBAIF9fRkJTRElEKCIkRnJlZUJTRCQiKTsKIAogLyogdGhlIGtlcm5lbCBwcm9jZXNz ICJ2bV9wYWdlb3V0IiovCiBzdGF0aWMgdm9pZCB2bV9wYWdlb3V0KHZvaWQpOworc3RhdGljIHZv aWQgdm1fcGFnZW91dF9pbml0KHZvaWQpOwogc3RhdGljIGludCB2bV9wYWdlb3V0X2NsZWFuKHZt X3BhZ2VfdCk7CiBzdGF0aWMgdm9pZCB2bV9wYWdlb3V0X3NjYW4oc3RydWN0IHZtX2RvbWFpbiAq dm1kLCBpbnQgcGFzcyk7CiBzdGF0aWMgdm9pZCB2bV9wYWdlb3V0X21pZ2h0YmVfb29tKHN0cnVj dCB2bV9kb21haW4gKnZtZCwgaW50IHBhc3MpOwogCitTWVNJTklUKHBhZ2VkYWVtb25faW5pdCwg U0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfRklSU1QsIHZtX3BhZ2VvdXRfaW5pdCwKKyAg ICBOVUxMKTsKKwogc3RydWN0IHByb2MgKnBhZ2Vwcm9jOwogCiBzdGF0aWMgc3RydWN0IGtwcm9j X2Rlc2MgcGFnZV9rcCA9IHsKQEAgLTEyNiw5ICsxMzIsMTMgQEAgc3RhdGljIHN0cnVjdCBrcHJv Y19kZXNjIHBhZ2Vfa3AgPSB7CiAJdm1fcGFnZW91dCwKIAkmcGFnZXByb2MKIH07Ci1TWVNJTklU KHBhZ2VkYWVtb24sIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX0ZJUlNULCBrcHJvY19z dGFydCwKK1NZU0lOSVQocGFnZWRhZW1vbiwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJf U0VDT05ELCBrcHJvY19zdGFydCwKICAgICAmcGFnZV9rcCk7CiAKK1NEVF9QUk9WSURFUl9ERUZJ TkUodm0pOworU0RUX1BST0JFX0RFRklORSh2bSwgLCAsIHZtX19sb3dtZW1fY2FjaGUpOworU0RU X1BST0JFX0RFRklORSh2bSwgLCAsIHZtX19sb3dtZW1fc2Nhbik7CisKICNpZiAhZGVmaW5lZChO T19TV0FQUElORykKIC8qIHRoZSBrZXJuZWwgcHJvY2VzcyAidm1fZGFlbW9uIiovCiBzdGF0aWMg dm9pZCB2bV9kYWVtb24odm9pZCk7CkBAIC02NjMsNiArNjczLDcgQEAgdm1fcGFnZW91dF9ncm93 X2NhY2hlKGludCB0cmllcywgdm1fcGFkZHJfdCBsb3csIHYKIAkJICogbWF5IGFjcXVpcmUgbG9j a3MgYW5kL29yIHNsZWVwLCBzbyB0aGV5IGNhbiBvbmx5IGJlIGludm9rZWQKIAkJICogd2hlbiAi dHJpZXMiIGlzIGdyZWF0ZXIgdGhhbiB6ZXJvLgogCQkgKi8KKwkJU0RUX1BST0JFMCh2bSwgLCAs IHZtX19sb3dtZW1fY2FjaGUpOwogCQlFVkVOVEhBTkRMRVJfSU5WT0tFKHZtX2xvd21lbSwgMCk7 CiAKIAkJLyoKQEAgLTkyMSwxMCArOTMyLDExIEBAIHZtX3BhZ2VvdXRfc2NhbihzdHJ1Y3Qgdm1f ZG9tYWluICp2bWQsIGludCBwYXNzKQogCSAqIHNvbWUuICBXZSByYXRlIGxpbWl0IHRvIGF2b2lk IHRocmFzaGluZy4KIAkgKi8KIAlpZiAodm1kID09ICZ2bV9kb21bMF0gJiYgcGFzcyA+IDAgJiYK LQkgICAgbG93bWVtX3RpY2tzICsgKGxvd21lbV9wZXJpb2QgKiBoeikgPCB0aWNrcykgeworCSAg ICAodGlja3MgLSBsb3dtZW1fdGlja3MpIC8gaHogPj0gbG93bWVtX3BlcmlvZCkgewogCQkvKgog CQkgKiBEZWNyZWFzZSByZWdpc3RlcmVkIGNhY2hlIHNpemVzLgogCQkgKi8KKwkJU0RUX1BST0JF MCh2bSwgLCAsIHZtX19sb3dtZW1fc2Nhbik7CiAJCUVWRU5USEFORExFUl9JTlZPS0Uodm1fbG93 bWVtLCAwKTsKIAkJLyoKIAkJICogV2UgZG8gdGhpcyBleHBsaWNpdGx5IGFmdGVyIHRoZSBjYWNo ZXMgaGF2ZSBiZWVuCkBAIC0xNjUwLDE1ICsxNjYyLDExIEBAIHZtX3BhZ2VvdXRfd29ya2VyKHZv aWQgKmFyZykKIH0KIAogLyoKLSAqCXZtX3BhZ2VvdXQgaXMgdGhlIGhpZ2ggbGV2ZWwgcGFnZW91 dCBkYWVtb24uCisgKgl2bV9wYWdlb3V0X2luaXQgaW5pdGlhbGlzZXMgYmFzaWMgcGFnZW91dCBk YWVtb24gc2V0dGluZ3MuCiAgKi8KIHN0YXRpYyB2b2lkCi12bV9wYWdlb3V0KHZvaWQpCit2bV9w YWdlb3V0X2luaXQodm9pZCkKIHsKLSNpZiBNQVhNRU1ET00gPiAxCi0JaW50IGVycm9yLCBpOwot I2VuZGlmCi0KIAkvKgogCSAqIEluaXRpYWxpemUgc29tZSBwYWdpbmcgcGFyYW1ldGVycy4KIAkg Ki8KQEAgLTE3MDQsNyArMTcxMiwxOCBAQCBzdGF0aWMgdm9pZAogCS8qIFhYWCBkb2VzIG5vdCBy ZWFsbHkgYmVsb25nIGhlcmUgKi8KIAlpZiAodm1fcGFnZV9tYXhfd2lyZWQgPT0gMCkKIAkJdm1f cGFnZV9tYXhfd2lyZWQgPSBjbnQudl9mcmVlX2NvdW50IC8gMzsKK30KIAorLyoKKyAqICAgICB2 bV9wYWdlb3V0IGlzIHRoZSBoaWdoIGxldmVsIHBhZ2VvdXQgZGFlbW9uLgorICovCitzdGF0aWMg dm9pZAordm1fcGFnZW91dCh2b2lkKQoreworI2lmIE1BWE1FTURPTSA+IDEKKwlpbnQgZXJyb3Is IGk7CisjZW5kaWYKKwogCXN3YXBfcGFnZXJfc3dhcF9pbml0KCk7CiAjaWYgTUFYTUVNRE9NID4g MQogCWZvciAoaSA9IDE7IGkgPCB2bV9uZG9tYWluczsgaSsrKSB7Cg== 152852 2015-02-10 21:44:49 +0000 2015-02-10 21:44:49 +0000 ARC Refactor / UMA Cleardown / DMU_TX dynamic against 10.1-STABLE patch.10-1.STABLE text/plain 10706 karl SW5kZXg6IGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMv YXJjLmMJKHJldmlzaW9uIDI3ODUyNCkKKysrIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMv Y29tbW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMTkwLDYgKzE5MCwxNSBAQCBz dGF0aWMgaW50IGFyY19kZWFkOwogZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hfZGlzYWJsZTsKIAog LyoKKyAqIEtEIDIwMTUtMDItMTAKKyAqIFdlIGhhdmUgdG8gYmUgYWJsZSB0byB0ZXN0IGZvciBV SU8gdXNlIGluc2lkZSB0aGUgYXJjIGFsbG9jYXRvci4KKyAqIE5PVEU6IERPIE5PVCBNT0RJRlkg SEVSRSEKKyAqLworZXh0ZXJuIGludCB6aW9fdXNlX3VtYTsKK2V4dGVybiBpbnQgemZzX2R5bmFt aWNfd3JpdGVfYnVmZmVyOworCisKKy8qCiAgKiBUaGUgYXJjIGhhcyBmaWxsZWQgYXZhaWxhYmxl IG1lbW9yeSBhbmQgaGFzIG5vdyB3YXJtZWQgdXAuCiAgKi8KIHN0YXRpYyBib29sZWFuX3QgYXJj X3dhcm07CkBAIC0yMTIsNyArMjIxLDcgQEAgc3RhdGljIHZvaWQKIGFyY19mcmVlX3RhcmdldF9p bml0KHZvaWQgKnVudXNlZCBfX3VudXNlZCkKIHsKIAotCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2 bV9wYWdlb3V0X3dha2V1cF90aHJlc2g7CisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2Vv dXRfd2FrZXVwX3RocmVzaCArICgoY250LnZfZnJlZV90YXJnZXQgLSB2bV9wYWdlb3V0X3dha2V1 cF90aHJlc2gpIC8gMik7CiB9CiBTWVNJTklUKGFyY19mcmVlX3RhcmdldF9pbml0LCBTSV9TVUJf S1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9BTlksCiAgICAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIE5V TEwpOwpAQCAtMjMzLDcgKzI0Miw5IEBAIFNZU0NUTF9VUVVBRChfdmZzX3pmcywgT0lEX0FVVE8s IGFyY19hdmVyYWdlX2Jsb2NrCiBTWVNDVExfSU5UKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX3No cmlua19zaGlmdCwgQ1RMRkxBR19SVywKICAgICAmYXJjX3Nocmlua19zaGlmdCwgMCwKICAgICAi bG9nMihmcmFjdGlvbiBvZiBhcmMgdG8gcmVjbGFpbSkiKTsKLQorU1lTQ1RMX0lOVChfdmZzX3pm cywgT0lEX0FVVE8sIGR5bmFtaWNfd3JpdGVfYnVmZmVyLCBDVExGTEFHX1JXVFVOLAorICAgICZ6 ZnNfZHluYW1pY193cml0ZV9idWZmZXIsIDAsCisgICAgIkR5bmFtaWNhbGx5IHJlc3RyaWN0IGRp cnR5IGRhdGEgd2hlbiBtZW1vcnkgaXMgbG93Iik7CiAvKgogICogV2UgZG9uJ3QgaGF2ZSBhIHR1 bmFibGUgZm9yIGFyY19mcmVlX3RhcmdldCBkdWUgdG8gdGhlIGRlcGVuZGVuY3kgb24KICAqIHBh Z2VkYWVtb24gaW5pdGlhbGlzYXRpb24uCkBAIC0yNjM1LDYgKzI2NDYsMjggQEAgZXh0ZXJuIGtt ZW1fY2FjaGVfdAkqemlvX2J1Zl9jYWNoZVtdOwogZXh0ZXJuIGttZW1fY2FjaGVfdAkqemlvX2Rh dGFfYnVmX2NhY2hlW107CiBleHRlcm4ga21lbV9jYWNoZV90CSpyYW5nZV9zZWdfY2FjaGU7CiAK K3N0YXRpYyB2b2lkIF9fdXNlZAorcmVhcF9hcmNfY2FjaGVzKCkKK3sKKwlzaXplX3QgICAgICAg ICAgaTsKKwlrbWVtX2NhY2hlX3QgICAgICAgICAgICAqcHJldl9jYWNoZSA9IE5VTEw7CisJa21l bV9jYWNoZV90ICAgICAgICAgICAgKnByZXZfZGF0YV9jYWNoZSA9IE5VTEw7CisKKwlmb3IgKGkg PSAwOyBpIDwgU1BBX01BWEJMT0NLU0laRSA+PiBTUEFfTUlOQkxPQ0tTSElGVDsgaSsrKSB7CisJ CWlmICh6aW9fYnVmX2NhY2hlW2ldICE9IHByZXZfY2FjaGUpIHsKKwkJCXByZXZfY2FjaGUgPSB6 aW9fYnVmX2NhY2hlW2ldOworCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6aW9fYnVmX2NhY2hlW2ld KTsKKwkJfQorCQlpZiAoemlvX2RhdGFfYnVmX2NhY2hlW2ldICE9IHByZXZfZGF0YV9jYWNoZSkg eworCQkJcHJldl9kYXRhX2NhY2hlID0gemlvX2RhdGFfYnVmX2NhY2hlW2ldOworCQkJa21lbV9j YWNoZV9yZWFwX25vdyh6aW9fZGF0YV9idWZfY2FjaGVbaV0pOworCQl9CisJfQorCWttZW1fY2Fj aGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKKwlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9jYWNoZSk7 CisJa21lbV9jYWNoZV9yZWFwX25vdyhyYW5nZV9zZWdfY2FjaGUpOworfQorCiBzdGF0aWMgdm9p ZCBfX25vaW5saW5lCiBhcmNfa21lbV9yZWFwX25vdyhhcmNfcmVjbGFpbV9zdHJhdGVneV90IHN0 cmF0KQogewpAQCAtMjY2NiwxOSArMjY5OSw3IEBAIGFyY19rbWVtX3JlYXBfbm93KGFyY19yZWNs YWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJaWYgKHN0cmF0ID09IEFSQ19SRUNMQUlNX0FHR1IpCiAJ CWFyY19zaHJpbmsoKTsKIAotCWZvciAoaSA9IDA7IGkgPCBTUEFfTUFYQkxPQ0tTSVpFID4+IFNQ QV9NSU5CTE9DS1NISUZUOyBpKyspIHsKLQkJaWYgKHppb19idWZfY2FjaGVbaV0gIT0gcHJldl9j YWNoZSkgewotCQkJcHJldl9jYWNoZSA9IHppb19idWZfY2FjaGVbaV07Ci0JCQlrbWVtX2NhY2hl X3JlYXBfbm93KHppb19idWZfY2FjaGVbaV0pOwotCQl9Ci0JCWlmICh6aW9fZGF0YV9idWZfY2Fj aGVbaV0gIT0gcHJldl9kYXRhX2NhY2hlKSB7Ci0JCQlwcmV2X2RhdGFfY2FjaGUgPSB6aW9fZGF0 YV9idWZfY2FjaGVbaV07Ci0JCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19kYXRhX2J1Zl9jYWNo ZVtpXSk7Ci0JCX0KLQl9Ci0Ja21lbV9jYWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOwotCWttZW1f Y2FjaGVfcmVhcF9ub3coaGRyX2NhY2hlKTsKLQlrbWVtX2NhY2hlX3JlYXBfbm93KHJhbmdlX3Nl Z19jYWNoZSk7CisJcmVhcF9hcmNfY2FjaGVzKCk7CiAKICNpZmRlZiBzdW4KIAkvKgpAQCAtMjY5 NywxMSArMjcxOCwyOSBAQCBhcmNfcmVjbGFpbV90aHJlYWQodm9pZCAqZHVtbXkgX191bnVzZWQp CiAJY2xvY2tfdAkJCWdyb3d0aW1lID0gMDsKIAlhcmNfcmVjbGFpbV9zdHJhdGVneV90CWxhc3Rf cmVjbGFpbSA9IEFSQ19SRUNMQUlNX0NPTlM7CiAJY2FsbGJfY3ByX3QJCWNwcjsKKwlpbnQJCQlh dXRvcmVhcCA9IDA7CiAKIAlDQUxMQl9DUFJfSU5JVCgmY3ByLCAmYXJjX3JlY2xhaW1fdGhyX2xv Y2ssIGNhbGxiX2dlbmVyaWNfY3ByLCBGVEFHKTsKIAogCW11dGV4X2VudGVyKCZhcmNfcmVjbGFp bV90aHJfbG9jayk7CiAJd2hpbGUgKGFyY190aHJlYWRfZXhpdCA9PSAwKSB7CisKKyNpZmRlZiBf S0VSTkVMCisvKiBLRCAyMDE1LTAyLTEwCisgKiBQcm90ZWN0IGFnYWluc3QgVU1BIGZyZWUgbWVt b3J5IGJsb2F0LiAgV2UgYWxyZWFkeSBkbyB0aGlzIG9uIGEgbG93LW1lbW9yeQorICogYmFzaXMg aW4gdGhlIGFsbG9jYXRvcjsgaXQgaGFzIHRvIGhhcHBlbiB0aGVyZSByYXRoZXIgdGhhbiBoZXJl IGR1ZSB0bworICogcmVzcG9uc2UgdGltZSBjb25zaWRlcmF0aW9ucy4gIE1ha2UgdGhlIGNhbGwg aGVyZSBvbmNlIGV2ZXJ5IDEwIHBhc3NlcyBhcworICogd2VsbDsgdGhpcyByZWNsYWltcyB1bnVz ZWQgVU1BIGJ1ZmZlcnMgZXZlcnkgMTAgc2Vjb25kcyBvbiBhbiBpZGxlIHN5c3RlbQorICogYW5k IG1vcmUgZnJlcXVlbnRseSBpZiB0aGUgcmVjbGFpbSB0aHJlYWQgZ2V0cyB3b2tlbiB1cCBieSBs b3cgUkFNCisgKiBjb25kaXRpb25zLgorICovCisJCWlmICgoemlvX3VzZV91bWEpICYmIChhdXRv cmVhcCsrID09IDEwKSkgeworCQkJYXV0b3JlYXAgPSAwOworCQkJRFRSQUNFX1BST0JFKGFyY19f cmVjbGFpbV90aW1lZF9yZWFwKTsKKwkJCXJlYXBfYXJjX2NhY2hlcygpOworCQl9CisjZW5kaWYg LyogX0tFUk5FTCAqLworCiAJCWlmIChhcmNfcmVjbGFpbV9uZWVkZWQoKSkgewogCiAJCQlpZiAo YXJjX25vX2dyb3cpIHsKQEAgLTI4ODksNiArMjkyOCwxOSBAQCBhcmNfZ2V0X2RhdGFfYnVmKGFy Y19idWZfdCAqYnVmKQogCQkJYXJjX3NwYWNlX2NvbnN1bWUoc2l6ZSwgQVJDX1NQQUNFX0RBVEEp OwogCQl9IGVsc2UgewogCQkJQVNTRVJUKHR5cGUgPT0gQVJDX0JVRkNfREFUQSk7CisjaWZkZWYg X0tFUk5FTAorLyogS0QgMjAxNS0wMi0xMAorICogSXQgd291bGQgYmUgbmljZSBpZiB3ZSBjb3Vs ZCBsZWF2ZSB0aGlzIHRvIHRoZSBhcmNfcmVjbGFpbSB0aHJlYWQuCisgKiBVbmZvcnR1bmF0ZWx5 IHdlIGNhbm5vdDsgdGhlIHRlc3QgaGFzIHRvIGJlIGRvbmUgaGVyZSBhcyB3ZWxsLCBiZWNhdXNl CisgKiB1bmRlciBoZWF2eSBJL08gZGVtYW5kIHdlIGNhbiBncmFiIGVub3VnaCBSQU0gZmFzdCBl bm91Z2ggdG8gaW5kdWNlCisgKiBuYXN0eSBvc2NpbGxhdGlvbiBwcm9ibGVtcy4gIEZvcnR1bmF0 ZWx5IHdlIG9ubHkgbmVlZCB0byBjYWxsIHRoaXMgd2hlbgorICogdGhlIHN5c3RlbSBpcyB1bmRl ciByZWFzb25hYmx5LXNldmVyZSBtZW1vcnkgc3RyZXNzLgorICovCisJCQlpZiAoemlvX3VzZV91 bWEgJiYgKHB0b2IoY250LnZfZnJlZV9jb3VudCkgKyBzaXplIDwgcHRvYihjbnQudl9mcmVlX3Rh cmdldCkpKSB7CisJCQkJRFRSQUNFX1BST0JFMyhhcmNfX2FsbG9jX2xvd21lbV9yZWFwLCBpbnQs IGNudC52X2ZyZWVfY291bnQsIGludCwgc2l6ZSwgaW50LCBjbnQudl9mcmVlX3RhcmdldCk7CisJ CQkJcmVhcF9hcmNfY2FjaGVzKCk7CisJCQl9CisjZW5kaWYgLyogX0tFUk5FTCAqLwogCQkJYnVm LT5iX2RhdGEgPSB6aW9fZGF0YV9idWZfYWxsb2Moc2l6ZSk7CiAJCQlBUkNTVEFUX0lOQ1IoYXJj c3RhdF9kYXRhX3NpemUsIHNpemUpOwogCQkJYXRvbWljX2FkZF82NCgmYXJjX3NpemUsIHNpemUp OwpJbmRleDogY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90 eC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2Zz L3pmcy9kbXVfdHguYwkocmV2aXNpb24gMjc4NTI0KQorKysgY2RkbC9jb250cmliL29wZW5zb2xh cmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90eC5jCSh3b3JraW5nIGNvcHkpCkBAIC00Miw2ICs0 Miw4IEBACiB0eXBlZGVmIHZvaWQgKCpkbXVfdHhfaG9sZF9mdW5jX3QpKGRtdV90eF90ICp0eCwg c3RydWN0IGRub2RlICpkbiwKICAgICB1aW50NjRfdCBhcmcxLCB1aW50NjRfdCBhcmcyKTsKIAor ZXh0ZXJuCWludAl6aW9fdXNlX3VtYTsJLyogTmVlZHMgdG8gYmUgdmlzaWJsZTsgRE8gTk9UIE1P RElGWSEgKi8KK2ludAl6ZnNfZHluYW1pY193cml0ZV9idWZmZXIgPSAxOwkvKiBEeW5hbWljYWxs eSB0dW5lIHdyaXRlcyAqLwogCiBkbXVfdHhfdCAqCiBkbXVfdHhfY3JlYXRlX2RkKGRzbF9kaXJf dCAqZGQpCkBAIC0xMDU4LDcgKzEwNjAsNyBAQCBkbXVfdHhfZGVsYXkoZG11X3R4X3QgKnR4LCB1 aW50NjRfdCBkaXJ0eSkKIHsKIAlkc2xfcG9vbF90ICpkcCA9IHR4LT50eF9wb29sOwogCXVpbnQ2 NF90IGRlbGF5X21pbl9ieXRlcyA9Ci0JICAgIHpmc19kaXJ0eV9kYXRhX21heCAqIHpmc19kZWxh eV9taW5fZGlydHlfcGVyY2VudCAvIDEwMDsKKwkgICAgemZzX2RpcnR5X2RhdGFfbWF4X2ludGVy bmFsICogemZzX2RlbGF5X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOwogCWhydGltZV90IHdha2V1 cCwgbWluX3R4X3RpbWUsIG5vdzsKIAogCWlmIChkaXJ0eSA8PSBkZWxheV9taW5fYnl0ZXMpCkBA IC0xMDcwLDExICsxMDcyLDExIEBAIGRtdV90eF9kZWxheShkbXVfdHhfdCAqdHgsIHVpbnQ2NF90 IGRpcnR5KQogCSAqIGhhdmUgdG8gaGFuZGxlIHRoZSBjYXNlIG9mIGl0IGJlaW5nID49IHRoZSBt YXgsIHdoaWNoIGNvdWxkCiAJICogY2F1c2UgYSBkaXZpZGUtYnktemVybyBpZiBpdCdzID09IHRo ZSBtYXguCiAJICovCi0JQVNTRVJUM1UoZGlydHksIDwsIHpmc19kaXJ0eV9kYXRhX21heCk7CisJ QVNTRVJUM1UoZGlydHksIDwsIHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCk7CiAKIAlub3cg PSBnZXRocnRpbWUoKTsKIAltaW5fdHhfdGltZSA9IHpmc19kZWxheV9zY2FsZSAqCi0JICAgIChk aXJ0eSAtIGRlbGF5X21pbl9ieXRlcykgLyAoemZzX2RpcnR5X2RhdGFfbWF4IC0gZGlydHkpOwor CSAgICAoZGlydHkgLSBkZWxheV9taW5fYnl0ZXMpIC8gKHpmc19kaXJ0eV9kYXRhX21heF9pbnRl cm5hbCAtIGRpcnR5KTsKIAlpZiAobm93ID4gdHgtPnR4X3N0YXJ0ICsgbWluX3R4X3RpbWUpCiAJ CXJldHVybjsKIApAQCAtMTI3OSw2ICsxMjgxLDcgQEAgaW50CiBkbXVfdHhfYXNzaWduKGRtdV90 eF90ICp0eCwgdHhnX2hvd190IHR4Z19ob3cpCiB7CiAJaW50IGVycjsKKwlzdGF0aWMJdWludDY0 X3QJbGFzdF9tYXg7CiAKIAlBU1NFUlQodHgtPnR4X3R4ZyA9PSAwKTsKIAlBU1NFUlQodHhnX2hv dyA9PSBUWEdfV0FJVCB8fCB0eGdfaG93ID09IFRYR19OT1dBSVQgfHwKQEAgLTEyOTEsNiArMTI5 NCw0MiBAQCBkbXVfdHhfYXNzaWduKGRtdV90eF90ICp0eCwgdHhnX2hvd190IHR4Z19ob3cpCiAJ aWYgKHR4Z19ob3cgPT0gVFhHX1dBSVRFRCkKIAkJdHgtPnR4X3dhaXRlZCA9IEJfVFJVRTsKIAor I2lmZGVmIF9LRVJORUwKKwkvKgorCSAqIEtEIDIwMTQtMDktMjIKKwkgKiBJZiBVTUEgaXMgZW5h YmxlZCBpdCBjYW4gb25seSByZXR1cm4gYSBwcmV2aW91c2x5LXVzZWQgYmxvY2sKKwkgKiBvZiBp ZGVudGljYWwgc2l6ZSB0byB3aGF0IGl0IGhhZCBvdXQgYmVmb3JlLiAgSWYgaXQncyBub3QgdGhl CisJICogc2FtZSBzaXplIGl0IHdpbGwgYWxsb2NhdGUgYSBuZXcgb25lLiAgVGhpcyBpcyBhIHBy b2JsZW0gYmVjYXVzZQorCSAqIGRpcnR5X2RhdGFfbWF4IGlzIHRoZSB0b3RhbCBkaXJ0eSB3cml0 ZSBkYXRhIGFsbG93ZWQgb3V0IGF0IGFueQorCSAqIGdpdmVuIHRpbWUsIGJ1dCB3aXRoIFVNQSBv biB0aGF0IGNhbiBtdWx0aXBseSBieSB0aGUgbnVtYmVyIG9mCisJICogZGlmZmVyZW50IGJsb2Nr IHNpemVzICghISkgcmVxdWVzdGVkIGluIHRlcm1zIG9mIGZyZWUgUkFNIHRoYXQKKwkgKiBpcyBs ZWZ0IGFsbG9jYXRlZCBidXQgdW51c2VkLiAgRm9yIHRoaXMgcmVhc29uIG5ldmVyIGFsbG93CisJ ICogZGlydHlfZGF0YV9tYXggdG8gZXhjZWVkIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gdGhlIHBh Z2luZworCSAqIHRocmVzaG9sZCBhbmQgdGhlIGN1cnJlbnQgZnJlZSBtZW1vcnksIHdpdGggYSBt aW5pbXVtIG9mIDI1Nk1CLgorCSAqIFRoaXMgdGhyb3R0bGVzICJidXJzdCIgYWxsb2NhdGlvbnMg YW5kIHByZXZlbnRzIHRoZSBzeXN0ZW0gZnJvbQorCSAqIGNob2tpbmcgZHVyaW5nIHRpbWVzIG9m IGhpZ2ggd3JpdGUgSS9PIGRlbWFuZC4KKwkgKgorCSAqIFdlIGFsbG93IHRoaXMgdG8gYmUgdHVy bmVkIG9mZiBpZiB5b3Ugd2FudCB3aXRoCisJICogInZmcy56ZnNfZHluYW1pY193cml0ZV9idWZm ZXI9MCIsIHdoaWNoIGNhbiBiZSBkb25lIGluIHJlYWwgdGltZS4KKwkgKgorCSAqIE5vdGUgdGhh dCB3ZSB3b3JrIG9uIHRoZSB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgdmFyaWFibGUsCisJ ICogYmVjYXVzZSB0aGUgdXNlciBtYXkgc2V0IHpmc19kaXJ0eV9kYXRhX21heCBoaW1zZWxmIGFu ZCB3ZSBtdXN0CisJICogbXVzdCBob25vciB0aGF0IGFzIGEgaGFyZCBjYXAgc28gaXQgcmVtYWlu cyBhIHVzYWJsZSB0dW5hYmxlIHZhbHVlLgorCSAqLworCWlmICh6aW9fdXNlX3VtYSAmIHpmc19k eW5hbWljX3dyaXRlX2J1ZmZlcikgeworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSAx IDw8IDI4OworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBNQVgoemZzX2RpcnR5X2Rh dGFfbWF4X2ludGVybmFsLCBwdG9iKGNudC52X2ZyZWVfY291bnQgLSBjbnQudl9mcmVlX3Rhcmdl dCkpOworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBNSU4oemZzX2RpcnR5X2RhdGFf bWF4X2ludGVybmFsLCB6ZnNfZGlydHlfZGF0YV9tYXgpOworCQl6ZnNfZGlydHlfZGF0YV9tYXhf aW50ZXJuYWwgPSBNSU4oemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsLCB6ZnNfZGlydHlfZGF0 YV9tYXhfbWF4KTsKKwkJaWYgKGxhc3RfbWF4ICE9ICh6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJu YWwgLyAoMTAyNCAqIDEwMjQpKSkgeworCQkJbGFzdF9tYXggPSB6ZnNfZGlydHlfZGF0YV9tYXhf aW50ZXJuYWwgLyAoMTAyNCAqIDEwMjQpOworCQkJRFRSQUNFX1BST0JFMShkbXVfX3R4X2RpcnR5 LCB1aW50NjRfdCwgbGFzdF9tYXgpOworCQl9CisJfSBlbHNlIHsKKwkJemZzX2RpcnR5X2RhdGFf bWF4X2ludGVybmFsID0gemZzX2RpcnR5X2RhdGFfbWF4OworCX0KKyNlbmRpZiAvKiBfS0VSTkVM ICovCisKIAl3aGlsZSAoKGVyciA9IGRtdV90eF90cnlfYXNzaWduKHR4LCB0eGdfaG93KSkgIT0g MCkgewogCQlkbXVfdHhfdW5hc3NpZ24odHgpOwogCkBAIC0xMzIxLDcgKzEzNjAsNyBAQCBkbXVf dHhfd2FpdChkbXVfdHhfdCAqdHgpCiAJCSAqIHNwYWNlLgogCQkgKi8KIAkJbXV0ZXhfZW50ZXIo JmRwLT5kcF9sb2NrKTsKLQkJd2hpbGUgKGRwLT5kcF9kaXJ0eV90b3RhbCA+PSB6ZnNfZGlydHlf ZGF0YV9tYXgpCisJCXdoaWxlIChkcC0+ZHBfZGlydHlfdG90YWwgPj0gemZzX2RpcnR5X2RhdGFf bWF4X2ludGVybmFsKQogCQkJY3Zfd2FpdCgmZHAtPmRwX3NwYWNlYXZhaWxfY3YsICZkcC0+ZHBf bG9jayk7CiAJCXVpbnQ2NF90IGRpcnR5ID0gZHAtPmRwX2RpcnR5X3RvdGFsOwogCQltdXRleF9l eGl0KCZkcC0+ZHBfbG9jayk7CkluZGV4OiBjZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2Nv bW1vbi9mcy96ZnMvZHNsX3Bvb2wuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNv bGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZHNsX3Bvb2wuYwkocmV2aXNpb24gMjc4NTI0KQorKysg Y2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RzbF9wb29sLmMJKHdv cmtpbmcgY29weSkKQEAgLTk3LDggKzk3LDExIEBACiAvKgogICogemZzX2RpcnR5X2RhdGFfbWF4 IHdpbGwgYmUgc2V0IHRvIHpmc19kaXJ0eV9kYXRhX21heF9wZXJjZW50JSBvZiBhbGwgbWVtb3J5 LAogICogY2FwcGVkIGF0IHpmc19kaXJ0eV9kYXRhX21heF9tYXguICBJdCBjYW4gYWxzbyBiZSBv dmVycmlkZGVuIGluIC9ldGMvc3lzdGVtLgorICogV2UgYWxzbyBkeW5hbWljYWxseSB0dW5lIGR1 cmluZyBsb3cgbWVtb3J5LCBob25vcmluZyB0aGUgc3lzY3RsIHNldCwgc28KKyAqIGludGVybmFs IGNvbXBhcmlzb25zIGFyZSBhZ2FpbnN0IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbC4KICAq LwogdWludDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4OwordWludDY0X3QgemZzX2RpcnR5X2RhdGFf bWF4X2ludGVybmFsOwogdWludDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4X21heCA9IDRVTEwgKiAx MDI0ICogMTAyNCAqIDEwMjQ7CiBpbnQgemZzX2RpcnR5X2RhdGFfbWF4X3BlcmNlbnQgPSAxMDsK IApAQCAtNTQ3LDcgKzU1MCw3IEBAIGRzbF9wb29sX2RpcnR5X2RlbHRhKGRzbF9wb29sX3QgKmRw LCBpbnQ2NF90IGRlbHRhCiAJICogTm90ZTogd2Ugc2lnbmFsIGV2ZW4gd2hlbiBpbmNyZWFzaW5n IGRwX2RpcnR5X3RvdGFsLgogCSAqIFRoaXMgZW5zdXJlcyBmb3J3YXJkIHByb2dyZXNzIC0tIGVh Y2ggdGhyZWFkIHdha2VzIHRoZSBuZXh0IHdhaXRlci4KIAkgKi8KLQlpZiAoZHAtPmRwX2RpcnR5 X3RvdGFsIDw9IHpmc19kaXJ0eV9kYXRhX21heCkKKwlpZiAoZHAtPmRwX2RpcnR5X3RvdGFsIDw9 IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCkKIAkJY3Zfc2lnbmFsKCZkcC0+ZHBfc3BhY2Vh dmFpbF9jdik7CiB9CiAKQEAgLTcyNiw3ICs3MjksNyBAQCBib29sZWFuX3QKIGRzbF9wb29sX25l ZWRfZGlydHlfZGVsYXkoZHNsX3Bvb2xfdCAqZHApCiB7CiAJdWludDY0X3QgZGVsYXlfbWluX2J5 dGVzID0KLQkgICAgemZzX2RpcnR5X2RhdGFfbWF4ICogemZzX2RlbGF5X21pbl9kaXJ0eV9wZXJj ZW50IC8gMTAwOworCSAgICB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgKiB6ZnNfZGVsYXlf bWluX2RpcnR5X3BlcmNlbnQgLyAxMDA7CiAJYm9vbGVhbl90IHJ2OwogCiAJbXV0ZXhfZW50ZXIo JmRwLT5kcF9sb2NrKTsKSW5kZXg6IGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9u L2ZzL3pmcy9zeXMvZHNsX3Bvb2wuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNv bGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvc3lzL2RzbF9wb29sLmgJKHJldmlzaW9uIDI3ODUyNCkK KysrIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9zeXMvZHNsX3Bv b2wuaAkod29ya2luZyBjb3B5KQpAQCAtNTAsNiArNTAsNyBAQCBzdHJ1Y3QgZG11X3R4Owogc3Ry dWN0IGRzbF9zY2FuOwogCiBleHRlcm4gdWludDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4OworZXh0 ZXJuIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbDsKIGV4dGVybiB1aW50NjRf dCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4OwogZXh0ZXJuIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRh X3N5bmM7CiBleHRlcm4gaW50IHpmc19kaXJ0eV9kYXRhX21heF9wZXJjZW50Owo= 158809 2015-07-15 17:23:24 +0000 2015-07-15 17:23:24 +0000 ARC Refactor / UMA Cleardown / DMU_TX dynamic against 10.2-BETA1 patch.10-2.BETA text/plain 11461 karl SW5kZXg6IGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMv YXJjLmMJKHJldmlzaW9uIDI4NTYwMikKKysrIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMv Y29tbW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMTkwLDYgKzE5MCwxNSBAQCBz dGF0aWMgaW50IGFyY19kZWFkOwogZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hfZGlzYWJsZTsKIAog LyoKKyAqIEtEIDIwMTUtMDItMTAKKyAqIFdlIGhhdmUgdG8gYmUgYWJsZSB0byB0ZXN0IGZvciBV SU8gdXNlIGluc2lkZSB0aGUgYXJjIGFsbG9jYXRvci4KKyAqIE5PVEU6IERPIE5PVCBNT0RJRlkg SEVSRSEKKyAqLworZXh0ZXJuIGludCB6aW9fdXNlX3VtYTsKK2V4dGVybiBpbnQgemZzX2R5bmFt aWNfd3JpdGVfYnVmZmVyOworCisKKy8qCiAgKiBUaGUgYXJjIGhhcyBmaWxsZWQgYXZhaWxhYmxl IG1lbW9yeSBhbmQgaGFzIG5vdyB3YXJtZWQgdXAuCiAgKi8KIHN0YXRpYyBib29sZWFuX3QgYXJj X3dhcm07CkBAIC0yMTIsNyArMjIxLDcgQEAgc3RhdGljIHZvaWQKIGFyY19mcmVlX3RhcmdldF9p bml0KHZvaWQgKnVudXNlZCBfX3VudXNlZCkKIHsKIAotCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2 bV9wYWdlb3V0X3dha2V1cF90aHJlc2g7CisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2Vv dXRfd2FrZXVwX3RocmVzaCArICgoY250LnZfZnJlZV90YXJnZXQgLSB2bV9wYWdlb3V0X3dha2V1 cF90aHJlc2gpIC8gMik7CiB9CiBTWVNJTklUKGFyY19mcmVlX3RhcmdldF9pbml0LCBTSV9TVUJf S1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9BTlksCiAgICAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIE5V TEwpOwpAQCAtMjMzLDcgKzI0Miw5IEBAIFNZU0NUTF9VUVVBRChfdmZzX3pmcywgT0lEX0FVVE8s IGFyY19hdmVyYWdlX2Jsb2NrCiBTWVNDVExfSU5UKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX3No cmlua19zaGlmdCwgQ1RMRkxBR19SVywKICAgICAmYXJjX3Nocmlua19zaGlmdCwgMCwKICAgICAi bG9nMihmcmFjdGlvbiBvZiBhcmMgdG8gcmVjbGFpbSkiKTsKLQorU1lTQ1RMX0lOVChfdmZzX3pm cywgT0lEX0FVVE8sIGR5bmFtaWNfd3JpdGVfYnVmZmVyLCBDVExGTEFHX1JXVFVOLAorICAgICZ6 ZnNfZHluYW1pY193cml0ZV9idWZmZXIsIDAsCisgICAgIkR5bmFtaWNhbGx5IHJlc3RyaWN0IGRp cnR5IGRhdGEgd2hlbiBtZW1vcnkgaXMgbG93Iik7CiAvKgogICogV2UgZG9uJ3QgaGF2ZSBhIHR1 bmFibGUgZm9yIGFyY19mcmVlX3RhcmdldCBkdWUgdG8gdGhlIGRlcGVuZGVuY3kgb24KICAqIHBh Z2VkYWVtb24gaW5pdGlhbGlzYXRpb24uCkBAIC0yNjQ1LDYgKzI2NTYsMjggQEAgZXh0ZXJuIGtt ZW1fY2FjaGVfdAkqemlvX2J1Zl9jYWNoZVtdOwogZXh0ZXJuIGttZW1fY2FjaGVfdAkqemlvX2Rh dGFfYnVmX2NhY2hlW107CiBleHRlcm4ga21lbV9jYWNoZV90CSpyYW5nZV9zZWdfY2FjaGU7CiAK K3N0YXRpYyB2b2lkIF9fdXNlZAorcmVhcF9hcmNfY2FjaGVzKCkKK3sKKwlzaXplX3QgICAgICAg ICAgaTsKKwlrbWVtX2NhY2hlX3QgICAgICAgICAgICAqcHJldl9jYWNoZSA9IE5VTEw7CisJa21l bV9jYWNoZV90ICAgICAgICAgICAgKnByZXZfZGF0YV9jYWNoZSA9IE5VTEw7CisKKwlmb3IgKGkg PSAwOyBpIDwgU1BBX01BWEJMT0NLU0laRSA+PiBTUEFfTUlOQkxPQ0tTSElGVDsgaSsrKSB7CisJ CWlmICh6aW9fYnVmX2NhY2hlW2ldICE9IHByZXZfY2FjaGUpIHsKKwkJCXByZXZfY2FjaGUgPSB6 aW9fYnVmX2NhY2hlW2ldOworCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6aW9fYnVmX2NhY2hlW2ld KTsKKwkJfQorCQlpZiAoemlvX2RhdGFfYnVmX2NhY2hlW2ldICE9IHByZXZfZGF0YV9jYWNoZSkg eworCQkJcHJldl9kYXRhX2NhY2hlID0gemlvX2RhdGFfYnVmX2NhY2hlW2ldOworCQkJa21lbV9j YWNoZV9yZWFwX25vdyh6aW9fZGF0YV9idWZfY2FjaGVbaV0pOworCQl9CisJfQorCWttZW1fY2Fj aGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKKwlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9jYWNoZSk7 CisJa21lbV9jYWNoZV9yZWFwX25vdyhyYW5nZV9zZWdfY2FjaGUpOworfQorCiBzdGF0aWMgdm9p ZCBfX25vaW5saW5lCiBhcmNfa21lbV9yZWFwX25vdyhhcmNfcmVjbGFpbV9zdHJhdGVneV90IHN0 cmF0KQogewpAQCAtMjY3NiwxOSArMjcwOSw3IEBAIGFyY19rbWVtX3JlYXBfbm93KGFyY19yZWNs YWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJaWYgKHN0cmF0ID09IEFSQ19SRUNMQUlNX0FHR1IpCiAJ CWFyY19zaHJpbmsoKTsKIAotCWZvciAoaSA9IDA7IGkgPCBTUEFfTUFYQkxPQ0tTSVpFID4+IFNQ QV9NSU5CTE9DS1NISUZUOyBpKyspIHsKLQkJaWYgKHppb19idWZfY2FjaGVbaV0gIT0gcHJldl9j YWNoZSkgewotCQkJcHJldl9jYWNoZSA9IHppb19idWZfY2FjaGVbaV07Ci0JCQlrbWVtX2NhY2hl X3JlYXBfbm93KHppb19idWZfY2FjaGVbaV0pOwotCQl9Ci0JCWlmICh6aW9fZGF0YV9idWZfY2Fj aGVbaV0gIT0gcHJldl9kYXRhX2NhY2hlKSB7Ci0JCQlwcmV2X2RhdGFfY2FjaGUgPSB6aW9fZGF0 YV9idWZfY2FjaGVbaV07Ci0JCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19kYXRhX2J1Zl9jYWNo ZVtpXSk7Ci0JCX0KLQl9Ci0Ja21lbV9jYWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOwotCWttZW1f Y2FjaGVfcmVhcF9ub3coaGRyX2NhY2hlKTsKLQlrbWVtX2NhY2hlX3JlYXBfbm93KHJhbmdlX3Nl Z19jYWNoZSk7CisJcmVhcF9hcmNfY2FjaGVzKCk7CiAKICNpZmRlZiBzdW4KIAkvKgpAQCAtMjcw NywxMSArMjcyOCwyOSBAQCBhcmNfcmVjbGFpbV90aHJlYWQodm9pZCAqZHVtbXkgX191bnVzZWQp CiAJY2xvY2tfdAkJCWdyb3d0aW1lID0gMDsKIAlhcmNfcmVjbGFpbV9zdHJhdGVneV90CWxhc3Rf cmVjbGFpbSA9IEFSQ19SRUNMQUlNX0NPTlM7CiAJY2FsbGJfY3ByX3QJCWNwcjsKKwlpbnQJCQlh dXRvcmVhcCA9IDA7CiAKIAlDQUxMQl9DUFJfSU5JVCgmY3ByLCAmYXJjX3JlY2xhaW1fdGhyX2xv Y2ssIGNhbGxiX2dlbmVyaWNfY3ByLCBGVEFHKTsKIAogCW11dGV4X2VudGVyKCZhcmNfcmVjbGFp bV90aHJfbG9jayk7CiAJd2hpbGUgKGFyY190aHJlYWRfZXhpdCA9PSAwKSB7CisKKyNpZmRlZiBf S0VSTkVMCisvKiBLRCAyMDE1LTAyLTEwCisgKiBQcm90ZWN0IGFnYWluc3QgVU1BIGZyZWUgbWVt b3J5IGJsb2F0LiAgV2UgYWxyZWFkeSBkbyB0aGlzIG9uIGEgbG93LW1lbW9yeQorICogYmFzaXMg aW4gdGhlIGFsbG9jYXRvcjsgaXQgaGFzIHRvIGhhcHBlbiB0aGVyZSByYXRoZXIgdGhhbiBoZXJl IGR1ZSB0bworICogcmVzcG9uc2UgdGltZSBjb25zaWRlcmF0aW9ucy4gIE1ha2UgdGhlIGNhbGwg aGVyZSBvbmNlIGV2ZXJ5IDEwIHBhc3NlcyBhcworICogd2VsbDsgdGhpcyByZWNsYWltcyB1bnVz ZWQgVU1BIGJ1ZmZlcnMgZXZlcnkgMTAgc2Vjb25kcyBvbiBhbiBpZGxlIHN5c3RlbQorICogYW5k IG1vcmUgZnJlcXVlbnRseSBpZiB0aGUgcmVjbGFpbSB0aHJlYWQgZ2V0cyB3b2tlbiB1cCBieSBs b3cgUkFNCisgKiBjb25kaXRpb25zLgorICovCisJCWlmICgoemlvX3VzZV91bWEpICYmIChhdXRv cmVhcCsrID09IDEwKSkgeworCQkJYXV0b3JlYXAgPSAwOworCQkJRFRSQUNFX1BST0JFKGFyY19f cmVjbGFpbV90aW1lZF9yZWFwKTsKKwkJCXJlYXBfYXJjX2NhY2hlcygpOworCQl9CisjZW5kaWYg LyogX0tFUk5FTCAqLworCiAJCWlmIChhcmNfcmVjbGFpbV9uZWVkZWQoKSkgewogCiAJCQlpZiAo YXJjX25vX2dyb3cpIHsKQEAgLTI4OTksNiArMjkzOCwxOSBAQCBhcmNfZ2V0X2RhdGFfYnVmKGFy Y19idWZfdCAqYnVmKQogCQkJYXJjX3NwYWNlX2NvbnN1bWUoc2l6ZSwgQVJDX1NQQUNFX0RBVEEp OwogCQl9IGVsc2UgewogCQkJQVNTRVJUKHR5cGUgPT0gQVJDX0JVRkNfREFUQSk7CisjaWZkZWYg X0tFUk5FTAorLyogS0QgMjAxNS0wMi0xMAorICogSXQgd291bGQgYmUgbmljZSBpZiB3ZSBjb3Vs ZCBsZWF2ZSB0aGlzIHRvIHRoZSBhcmNfcmVjbGFpbSB0aHJlYWQuCisgKiBVbmZvcnR1bmF0ZWx5 IHdlIGNhbm5vdDsgdGhlIHRlc3QgaGFzIHRvIGJlIGRvbmUgaGVyZSBhcyB3ZWxsLCBiZWNhdXNl CisgKiB1bmRlciBoZWF2eSBJL08gZGVtYW5kIHdlIGNhbiBncmFiIGVub3VnaCBSQU0gZmFzdCBl bm91Z2ggdG8gaW5kdWNlCisgKiBuYXN0eSBvc2NpbGxhdGlvbiBwcm9ibGVtcy4gIEZvcnR1bmF0 ZWx5IHdlIG9ubHkgbmVlZCB0byBjYWxsIHRoaXMgd2hlbgorICogdGhlIHN5c3RlbSBpcyB1bmRl ciByZWFzb25hYmx5LXNldmVyZSBtZW1vcnkgc3RyZXNzLgorICovCisJCQlpZiAoemlvX3VzZV91 bWEgJiYgKHB0b2IoY250LnZfZnJlZV9jb3VudCkgKyBzaXplIDwgcHRvYihjbnQudl9mcmVlX3Rh cmdldCkpKSB7CisJCQkJRFRSQUNFX1BST0JFMyhhcmNfX2FsbG9jX2xvd21lbV9yZWFwLCBpbnQs IGNudC52X2ZyZWVfY291bnQsIGludCwgc2l6ZSwgaW50LCBjbnQudl9mcmVlX3RhcmdldCk7CisJ CQkJcmVhcF9hcmNfY2FjaGVzKCk7CisJCQl9CisjZW5kaWYgLyogX0tFUk5FTCAqLwogCQkJYnVm LT5iX2RhdGEgPSB6aW9fZGF0YV9idWZfYWxsb2Moc2l6ZSk7CiAJCQlBUkNTVEFUX0lOQ1IoYXJj c3RhdF9kYXRhX3NpemUsIHNpemUpOwogCQkJYXRvbWljX2FkZF82NCgmYXJjX3NpemUsIHNpemUp OwpJbmRleDogY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90 eC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2Zz L3pmcy9kbXVfdHguYwkocmV2aXNpb24gMjg1NjAyKQorKysgY2RkbC9jb250cmliL29wZW5zb2xh cmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90eC5jCSh3b3JraW5nIGNvcHkpCkBAIC00Miw2ICs0 Miw4IEBACiB0eXBlZGVmIHZvaWQgKCpkbXVfdHhfaG9sZF9mdW5jX3QpKGRtdV90eF90ICp0eCwg c3RydWN0IGRub2RlICpkbiwKICAgICB1aW50NjRfdCBhcmcxLCB1aW50NjRfdCBhcmcyKTsKIAor ZXh0ZXJuCWludAl6aW9fdXNlX3VtYTsJLyogTmVlZHMgdG8gYmUgdmlzaWJsZTsgRE8gTk9UIE1P RElGWSEgKi8KK2ludAl6ZnNfZHluYW1pY193cml0ZV9idWZmZXIgPSAxOwkvKiBEeW5hbWljYWxs eSB0dW5lIHdyaXRlcyAqLwogCiBkbXVfdHhfdCAqCiBkbXVfdHhfY3JlYXRlX2RkKGRzbF9kaXJf dCAqZGQpCkBAIC0xMDU4LDcgKzEwNjAsNyBAQCBkbXVfdHhfZGVsYXkoZG11X3R4X3QgKnR4LCB1 aW50NjRfdCBkaXJ0eSkKIHsKIAlkc2xfcG9vbF90ICpkcCA9IHR4LT50eF9wb29sOwogCXVpbnQ2 NF90IGRlbGF5X21pbl9ieXRlcyA9Ci0JICAgIHpmc19kaXJ0eV9kYXRhX21heCAqIHpmc19kZWxh eV9taW5fZGlydHlfcGVyY2VudCAvIDEwMDsKKwkgICAgemZzX2RpcnR5X2RhdGFfbWF4X2ludGVy bmFsICogemZzX2RlbGF5X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOwogCWhydGltZV90IHdha2V1 cCwgbWluX3R4X3RpbWUsIG5vdzsKIAogCWlmIChkaXJ0eSA8PSBkZWxheV9taW5fYnl0ZXMpCkBA IC0xMDcwLDExICsxMDcyLDExIEBAIGRtdV90eF9kZWxheShkbXVfdHhfdCAqdHgsIHVpbnQ2NF90 IGRpcnR5KQogCSAqIGhhdmUgdG8gaGFuZGxlIHRoZSBjYXNlIG9mIGl0IGJlaW5nID49IHRoZSBt YXgsIHdoaWNoIGNvdWxkCiAJICogY2F1c2UgYSBkaXZpZGUtYnktemVybyBpZiBpdCdzID09IHRo ZSBtYXguCiAJICovCi0JQVNTRVJUM1UoZGlydHksIDwsIHpmc19kaXJ0eV9kYXRhX21heCk7CisJ QVNTRVJUM1UoZGlydHksIDwsIHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCk7CiAKIAlub3cg PSBnZXRocnRpbWUoKTsKIAltaW5fdHhfdGltZSA9IHpmc19kZWxheV9zY2FsZSAqCi0JICAgIChk aXJ0eSAtIGRlbGF5X21pbl9ieXRlcykgLyAoemZzX2RpcnR5X2RhdGFfbWF4IC0gZGlydHkpOwor CSAgICAoZGlydHkgLSBkZWxheV9taW5fYnl0ZXMpIC8gKHpmc19kaXJ0eV9kYXRhX21heF9pbnRl cm5hbCAtIGRpcnR5KTsKIAlpZiAobm93ID4gdHgtPnR4X3N0YXJ0ICsgbWluX3R4X3RpbWUpCiAJ CXJldHVybjsKIApAQCAtMTI3OSw2ICsxMjgxLDcgQEAgaW50CiBkbXVfdHhfYXNzaWduKGRtdV90 eF90ICp0eCwgdHhnX2hvd190IHR4Z19ob3cpCiB7CiAJaW50IGVycjsKKwlzdGF0aWMJdWludDY0 X3QJbGFzdF9tYXg7CiAKIAlBU1NFUlQodHgtPnR4X3R4ZyA9PSAwKTsKIAlBU1NFUlQodHhnX2hv dyA9PSBUWEdfV0FJVCB8fCB0eGdfaG93ID09IFRYR19OT1dBSVQgfHwKQEAgLTEyOTEsNiArMTI5 NCw0MiBAQCBkbXVfdHhfYXNzaWduKGRtdV90eF90ICp0eCwgdHhnX2hvd190IHR4Z19ob3cpCiAJ aWYgKHR4Z19ob3cgPT0gVFhHX1dBSVRFRCkKIAkJdHgtPnR4X3dhaXRlZCA9IEJfVFJVRTsKIAor I2lmZGVmIF9LRVJORUwKKwkvKgorCSAqIEtEIDIwMTQtMDktMjIKKwkgKiBJZiBVTUEgaXMgZW5h YmxlZCBpdCBjYW4gb25seSByZXR1cm4gYSBwcmV2aW91c2x5LXVzZWQgYmxvY2sKKwkgKiBvZiBp ZGVudGljYWwgc2l6ZSB0byB3aGF0IGl0IGhhZCBvdXQgYmVmb3JlLiAgSWYgaXQncyBub3QgdGhl CisJICogc2FtZSBzaXplIGl0IHdpbGwgYWxsb2NhdGUgYSBuZXcgb25lLiAgVGhpcyBpcyBhIHBy b2JsZW0gYmVjYXVzZQorCSAqIGRpcnR5X2RhdGFfbWF4IGlzIHRoZSB0b3RhbCBkaXJ0eSB3cml0 ZSBkYXRhIGFsbG93ZWQgb3V0IGF0IGFueQorCSAqIGdpdmVuIHRpbWUsIGJ1dCB3aXRoIFVNQSBv biB0aGF0IGNhbiBtdWx0aXBseSBieSB0aGUgbnVtYmVyIG9mCisJICogZGlmZmVyZW50IGJsb2Nr IHNpemVzICghISkgcmVxdWVzdGVkIGluIHRlcm1zIG9mIGZyZWUgUkFNIHRoYXQKKwkgKiBpcyBs ZWZ0IGFsbG9jYXRlZCBidXQgdW51c2VkLiAgRm9yIHRoaXMgcmVhc29uIG5ldmVyIGFsbG93CisJ ICogZGlydHlfZGF0YV9tYXggdG8gZXhjZWVkIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gdGhlIHBh Z2luZworCSAqIHRocmVzaG9sZCBhbmQgdGhlIGN1cnJlbnQgZnJlZSBtZW1vcnksIHdpdGggYSBt aW5pbXVtIG9mIDI1Nk1CLgorCSAqIFRoaXMgdGhyb3R0bGVzICJidXJzdCIgYWxsb2NhdGlvbnMg YW5kIHByZXZlbnRzIHRoZSBzeXN0ZW0gZnJvbQorCSAqIGNob2tpbmcgZHVyaW5nIHRpbWVzIG9m IGhpZ2ggd3JpdGUgSS9PIGRlbWFuZC4KKwkgKgorCSAqIFdlIGFsbG93IHRoaXMgdG8gYmUgdHVy bmVkIG9mZiBpZiB5b3Ugd2FudCB3aXRoCisJICogInZmcy56ZnNfZHluYW1pY193cml0ZV9idWZm ZXI9MCIsIHdoaWNoIGNhbiBiZSBkb25lIGluIHJlYWwgdGltZS4KKwkgKgorCSAqIE5vdGUgdGhh dCB3ZSB3b3JrIG9uIHRoZSB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgdmFyaWFibGUsCisJ ICogYmVjYXVzZSB0aGUgdXNlciBtYXkgc2V0IHpmc19kaXJ0eV9kYXRhX21heCBoaW1zZWxmIGFu ZCB3ZSBtdXN0CisJICogbXVzdCBob25vciB0aGF0IGFzIGEgaGFyZCBjYXAgc28gaXQgcmVtYWlu cyBhIHVzYWJsZSB0dW5hYmxlIHZhbHVlLgorCSAqLworCWlmICh6aW9fdXNlX3VtYSAmIHpmc19k eW5hbWljX3dyaXRlX2J1ZmZlcikgeworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSAx IDw8IDI4OworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBNQVgoemZzX2RpcnR5X2Rh dGFfbWF4X2ludGVybmFsLCBwdG9iKGNudC52X2ZyZWVfY291bnQgLSBjbnQudl9mcmVlX3Rhcmdl dCkpOworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBNSU4oemZzX2RpcnR5X2RhdGFf bWF4X2ludGVybmFsLCB6ZnNfZGlydHlfZGF0YV9tYXgpOworCQl6ZnNfZGlydHlfZGF0YV9tYXhf aW50ZXJuYWwgPSBNSU4oemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsLCB6ZnNfZGlydHlfZGF0 YV9tYXhfbWF4KTsKKwkJaWYgKGxhc3RfbWF4ICE9ICh6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJu YWwgLyAoMTAyNCAqIDEwMjQpKSkgeworCQkJbGFzdF9tYXggPSB6ZnNfZGlydHlfZGF0YV9tYXhf aW50ZXJuYWwgLyAoMTAyNCAqIDEwMjQpOworCQkJRFRSQUNFX1BST0JFMShkbXVfX3R4X2RpcnR5 LCB1aW50NjRfdCwgbGFzdF9tYXgpOworCQl9CisJfSBlbHNlIHsKKwkJemZzX2RpcnR5X2RhdGFf bWF4X2ludGVybmFsID0gemZzX2RpcnR5X2RhdGFfbWF4OworCX0KKyNlbmRpZiAvKiBfS0VSTkVM ICovCisKIAl3aGlsZSAoKGVyciA9IGRtdV90eF90cnlfYXNzaWduKHR4LCB0eGdfaG93KSkgIT0g MCkgewogCQlkbXVfdHhfdW5hc3NpZ24odHgpOwogCkBAIC0xMzIxLDcgKzEzNjAsNyBAQCBkbXVf dHhfd2FpdChkbXVfdHhfdCAqdHgpCiAJCSAqIHNwYWNlLgogCQkgKi8KIAkJbXV0ZXhfZW50ZXIo JmRwLT5kcF9sb2NrKTsKLQkJd2hpbGUgKGRwLT5kcF9kaXJ0eV90b3RhbCA+PSB6ZnNfZGlydHlf ZGF0YV9tYXgpCisJCXdoaWxlIChkcC0+ZHBfZGlydHlfdG90YWwgPj0gemZzX2RpcnR5X2RhdGFf bWF4X2ludGVybmFsKQogCQkJY3Zfd2FpdCgmZHAtPmRwX3NwYWNlYXZhaWxfY3YsICZkcC0+ZHBf bG9jayk7CiAJCXVpbnQ2NF90IGRpcnR5ID0gZHAtPmRwX2RpcnR5X3RvdGFsOwogCQltdXRleF9l eGl0KCZkcC0+ZHBfbG9jayk7CkluZGV4OiBjZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2Nv bW1vbi9mcy96ZnMvZHNsX3Bvb2wuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNv bGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZHNsX3Bvb2wuYwkocmV2aXNpb24gMjg1NjAyKQorKysg Y2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RzbF9wb29sLmMJKHdv cmtpbmcgY29weSkKQEAgLTk3LDggKzk3LDExIEBACiAvKgogICogemZzX2RpcnR5X2RhdGFfbWF4 IHdpbGwgYmUgc2V0IHRvIHpmc19kaXJ0eV9kYXRhX21heF9wZXJjZW50JSBvZiBhbGwgbWVtb3J5 LAogICogY2FwcGVkIGF0IHpmc19kaXJ0eV9kYXRhX21heF9tYXguICBJdCBjYW4gYWxzbyBiZSBv dmVycmlkZGVuIGluIC9ldGMvc3lzdGVtLgorICogV2UgYWxzbyBkeW5hbWljYWxseSB0dW5lIGR1 cmluZyBsb3cgbWVtb3J5LCBob25vcmluZyB0aGUgc3lzY3RsIHNldCwgc28KKyAqIGludGVybmFs IGNvbXBhcmlzb25zIGFyZSBhZ2FpbnN0IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbC4KICAq LwogdWludDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4OwordWludDY0X3QgemZzX2RpcnR5X2RhdGFf bWF4X2ludGVybmFsOwogdWludDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4X21heCA9IDRVTEwgKiAx MDI0ICogMTAyNCAqIDEwMjQ7CiBpbnQgemZzX2RpcnR5X2RhdGFfbWF4X3BlcmNlbnQgPSAxMDsK IApAQCAtNTQ3LDcgKzU1MCw3IEBAIGRzbF9wb29sX2RpcnR5X2RlbHRhKGRzbF9wb29sX3QgKmRw LCBpbnQ2NF90IGRlbHRhCiAJICogTm90ZTogd2Ugc2lnbmFsIGV2ZW4gd2hlbiBpbmNyZWFzaW5n IGRwX2RpcnR5X3RvdGFsLgogCSAqIFRoaXMgZW5zdXJlcyBmb3J3YXJkIHByb2dyZXNzIC0tIGVh Y2ggdGhyZWFkIHdha2VzIHRoZSBuZXh0IHdhaXRlci4KIAkgKi8KLQlpZiAoZHAtPmRwX2RpcnR5 X3RvdGFsIDw9IHpmc19kaXJ0eV9kYXRhX21heCkKKwlpZiAoZHAtPmRwX2RpcnR5X3RvdGFsIDw9 IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCkKIAkJY3Zfc2lnbmFsKCZkcC0+ZHBfc3BhY2Vh dmFpbF9jdik7CiB9CiAKQEAgLTcyNiw3ICs3MjksNyBAQCBib29sZWFuX3QKIGRzbF9wb29sX25l ZWRfZGlydHlfZGVsYXkoZHNsX3Bvb2xfdCAqZHApCiB7CiAJdWludDY0X3QgZGVsYXlfbWluX2J5 dGVzID0KLQkgICAgemZzX2RpcnR5X2RhdGFfbWF4ICogemZzX2RlbGF5X21pbl9kaXJ0eV9wZXJj ZW50IC8gMTAwOworCSAgICB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgKiB6ZnNfZGVsYXlf bWluX2RpcnR5X3BlcmNlbnQgLyAxMDA7CiAJYm9vbGVhbl90IHJ2OwogCiAJbXV0ZXhfZW50ZXIo JmRwLT5kcF9sb2NrKTsKSW5kZXg6IGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9u L2ZzL3pmcy9zeXMvZHNsX3Bvb2wuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNv bGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvc3lzL2RzbF9wb29sLmgJKHJldmlzaW9uIDI4NTYwMikK KysrIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9zeXMvZHNsX3Bv b2wuaAkod29ya2luZyBjb3B5KQpAQCAtNTAsNiArNTAsNyBAQCBzdHJ1Y3QgZG11X3R4Owogc3Ry dWN0IGRzbF9zY2FuOwogCiBleHRlcm4gdWludDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4OworZXh0 ZXJuIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbDsKIGV4dGVybiB1aW50NjRf dCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4OwogZXh0ZXJuIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRh X3N5bmM7CiBleHRlcm4gaW50IHpmc19kaXJ0eV9kYXRhX21heF9wZXJjZW50OwpJbmRleDogY2Rk bC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3ppby5jCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy96aW8uYwkocmV2 aXNpb24gMjg1NjAyKQorKysgY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMv emZzL3ppby5jCSh3b3JraW5nIGNvcHkpCkBAIC00MywxMCArNDMsMTMgQEAKIAogU1lTQ1RMX0RF Q0woX3Zmc196ZnMpOwogU1lTQ1RMX05PREUoX3Zmc196ZnMsIE9JRF9BVVRPLCB6aW8sIENUTEZM QUdfUlcsIDAsICJaRlMgWklPIik7CisvKiBLRCAyMDE1LTA3LTE1IENoYW5nZSBjbGFzcyB0byAi aW50IiBmcm9tICJzdGF0aWMgaW50IiBhcyB3ZSByZWZlcmVuY2UgCisgKiB0aGlzIGFzIGFuIGV4 dGVybiBlbHNld2hlcmUKKyAqLwogI2lmIGRlZmluZWQoX19hbWQ2NF9fKQotc3RhdGljIGludCB6 aW9fdXNlX3VtYSA9IDE7CitpbnQgemlvX3VzZV91bWEgPSAxOwogI2Vsc2UKLXN0YXRpYyBpbnQg emlvX3VzZV91bWEgPSAwOworaW50IHppb191c2VfdW1hID0gMDsKICNlbmRpZgogVFVOQUJMRV9J TlQoInZmcy56ZnMuemlvLnVzZV91bWEiLCAmemlvX3VzZV91bWEpOwogU1lTQ1RMX0lOVChfdmZz X3pmc196aW8sIE9JRF9BVVRPLCB1c2VfdW1hLCBDVExGTEFHX1JEVFVOLCAmemlvX3VzZV91bWEs IDAsCg== 159207 2015-07-25 05:14:09 +0000 2015-10-04 11:51:18 +0000 ARC Refactor / UMA Cleardown / DMU_TX dynamic against 10.2-r285717 and later patch.10-2.r285717 text/plain 11461 junchoon SW5kZXg6IGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMv YXJjLmMJKHJldmlzaW9uIDI4NTYwMikKKysrIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMv Y29tbW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMTkwLDYgKzE5MCwxNSBAQCBz dGF0aWMgaW50IGFyY19kZWFkOwogZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hfZGlzYWJsZTsKIAog LyoKKyAqIEtEIDIwMTUtMDItMTAKKyAqIFdlIGhhdmUgdG8gYmUgYWJsZSB0byB0ZXN0IGZvciBV SU8gdXNlIGluc2lkZSB0aGUgYXJjIGFsbG9jYXRvci4KKyAqIE5PVEU6IERPIE5PVCBNT0RJRlkg SEVSRSEKKyAqLworZXh0ZXJuIGludCB6aW9fdXNlX3VtYTsKK2V4dGVybiBpbnQgemZzX2R5bmFt aWNfd3JpdGVfYnVmZmVyOworCisKKy8qCiAgKiBUaGUgYXJjIGhhcyBmaWxsZWQgYXZhaWxhYmxl IG1lbW9yeSBhbmQgaGFzIG5vdyB3YXJtZWQgdXAuCiAgKi8KIHN0YXRpYyBib29sZWFuX3QgYXJj X3dhcm07CkBAIC0yMTIsNyArMjIxLDcgQEAgc3RhdGljIHZvaWQKIGFyY19mcmVlX3RhcmdldF9p bml0KHZvaWQgKnVudXNlZCBfX3VudXNlZCkKIHsKIAotCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2 bV9wYWdlb3V0X3dha2V1cF90aHJlc2g7CisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2Vv dXRfd2FrZXVwX3RocmVzaCArICgoY250LnZfZnJlZV90YXJnZXQgLSB2bV9wYWdlb3V0X3dha2V1 cF90aHJlc2gpIC8gMik7CiB9CiBTWVNJTklUKGFyY19mcmVlX3RhcmdldF9pbml0LCBTSV9TVUJf S1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9BTlksCiAgICAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIE5V TEwpOwpAQCAtMjMzLDcgKzI0Miw5IEBAIFNZU0NUTF9VUVVBRChfdmZzX3pmcywgT0lEX0FVVE8s IGFyY19hdmVyYWdlX2Jsb2NrCiBTWVNDVExfSU5UKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX3No cmlua19zaGlmdCwgQ1RMRkxBR19SVywKICAgICAmYXJjX3Nocmlua19zaGlmdCwgMCwKICAgICAi bG9nMihmcmFjdGlvbiBvZiBhcmMgdG8gcmVjbGFpbSkiKTsKLQorU1lTQ1RMX0lOVChfdmZzX3pm cywgT0lEX0FVVE8sIGR5bmFtaWNfd3JpdGVfYnVmZmVyLCBDVExGTEFHX1JXVFVOLAorICAgICZ6 ZnNfZHluYW1pY193cml0ZV9idWZmZXIsIDAsCisgICAgIkR5bmFtaWNhbGx5IHJlc3RyaWN0IGRp cnR5IGRhdGEgd2hlbiBtZW1vcnkgaXMgbG93Iik7CiAvKgogICogV2UgZG9uJ3QgaGF2ZSBhIHR1 bmFibGUgZm9yIGFyY19mcmVlX3RhcmdldCBkdWUgdG8gdGhlIGRlcGVuZGVuY3kgb24KICAqIHBh Z2VkYWVtb24gaW5pdGlhbGlzYXRpb24uCkBAIC0yNjQ1LDYgKzI2NTYsMjggQEAgZXh0ZXJuIGtt ZW1fY2FjaGVfdAkqemlvX2J1Zl9jYWNoZVtdOwogZXh0ZXJuIGttZW1fY2FjaGVfdAkqemlvX2Rh dGFfYnVmX2NhY2hlW107CiBleHRlcm4ga21lbV9jYWNoZV90CSpyYW5nZV9zZWdfY2FjaGU7CiAK K3N0YXRpYyB2b2lkIF9fdXNlZAorcmVhcF9hcmNfY2FjaGVzKCkKK3sKKwlzaXplX3QgICAgICAg ICAgaTsKKwlrbWVtX2NhY2hlX3QgICAgICAgICAgICAqcHJldl9jYWNoZSA9IE5VTEw7CisJa21l bV9jYWNoZV90ICAgICAgICAgICAgKnByZXZfZGF0YV9jYWNoZSA9IE5VTEw7CisKKwlmb3IgKGkg PSAwOyBpIDwgU1BBX01BWEJMT0NLU0laRSA+PiBTUEFfTUlOQkxPQ0tTSElGVDsgaSsrKSB7CisJ CWlmICh6aW9fYnVmX2NhY2hlW2ldICE9IHByZXZfY2FjaGUpIHsKKwkJCXByZXZfY2FjaGUgPSB6 aW9fYnVmX2NhY2hlW2ldOworCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6aW9fYnVmX2NhY2hlW2ld KTsKKwkJfQorCQlpZiAoemlvX2RhdGFfYnVmX2NhY2hlW2ldICE9IHByZXZfZGF0YV9jYWNoZSkg eworCQkJcHJldl9kYXRhX2NhY2hlID0gemlvX2RhdGFfYnVmX2NhY2hlW2ldOworCQkJa21lbV9j YWNoZV9yZWFwX25vdyh6aW9fZGF0YV9idWZfY2FjaGVbaV0pOworCQl9CisJfQorCWttZW1fY2Fj aGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKKwlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9jYWNoZSk7 CisJa21lbV9jYWNoZV9yZWFwX25vdyhyYW5nZV9zZWdfY2FjaGUpOworfQorCiBzdGF0aWMgX19u b2lubGluZSB2b2lkCiBhcmNfa21lbV9yZWFwX25vdyhhcmNfcmVjbGFpbV9zdHJhdGVneV90IHN0 cmF0KQogewpAQCAtMjY3NiwxOSArMjcwOSw3IEBAIGFyY19rbWVtX3JlYXBfbm93KGFyY19yZWNs YWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJaWYgKHN0cmF0ID09IEFSQ19SRUNMQUlNX0FHR1IpCiAJ CWFyY19zaHJpbmsoKTsKIAotCWZvciAoaSA9IDA7IGkgPCBTUEFfTUFYQkxPQ0tTSVpFID4+IFNQ QV9NSU5CTE9DS1NISUZUOyBpKyspIHsKLQkJaWYgKHppb19idWZfY2FjaGVbaV0gIT0gcHJldl9j YWNoZSkgewotCQkJcHJldl9jYWNoZSA9IHppb19idWZfY2FjaGVbaV07Ci0JCQlrbWVtX2NhY2hl X3JlYXBfbm93KHppb19idWZfY2FjaGVbaV0pOwotCQl9Ci0JCWlmICh6aW9fZGF0YV9idWZfY2Fj aGVbaV0gIT0gcHJldl9kYXRhX2NhY2hlKSB7Ci0JCQlwcmV2X2RhdGFfY2FjaGUgPSB6aW9fZGF0 YV9idWZfY2FjaGVbaV07Ci0JCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19kYXRhX2J1Zl9jYWNo ZVtpXSk7Ci0JCX0KLQl9Ci0Ja21lbV9jYWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOwotCWttZW1f Y2FjaGVfcmVhcF9ub3coaGRyX2NhY2hlKTsKLQlrbWVtX2NhY2hlX3JlYXBfbm93KHJhbmdlX3Nl Z19jYWNoZSk7CisJcmVhcF9hcmNfY2FjaGVzKCk7CiAKICNpZmRlZiBzdW4KIAkvKgpAQCAtMjcw NywxMSArMjcyOCwyOSBAQCBhcmNfcmVjbGFpbV90aHJlYWQodm9pZCAqZHVtbXkgX191bnVzZWQp CiAJY2xvY2tfdAkJCWdyb3d0aW1lID0gMDsKIAlhcmNfcmVjbGFpbV9zdHJhdGVneV90CWxhc3Rf cmVjbGFpbSA9IEFSQ19SRUNMQUlNX0NPTlM7CiAJY2FsbGJfY3ByX3QJCWNwcjsKKwlpbnQJCQlh dXRvcmVhcCA9IDA7CiAKIAlDQUxMQl9DUFJfSU5JVCgmY3ByLCAmYXJjX3JlY2xhaW1fdGhyX2xv Y2ssIGNhbGxiX2dlbmVyaWNfY3ByLCBGVEFHKTsKIAogCW11dGV4X2VudGVyKCZhcmNfcmVjbGFp bV90aHJfbG9jayk7CiAJd2hpbGUgKGFyY190aHJlYWRfZXhpdCA9PSAwKSB7CisKKyNpZmRlZiBf S0VSTkVMCisvKiBLRCAyMDE1LTAyLTEwCisgKiBQcm90ZWN0IGFnYWluc3QgVU1BIGZyZWUgbWVt b3J5IGJsb2F0LiAgV2UgYWxyZWFkeSBkbyB0aGlzIG9uIGEgbG93LW1lbW9yeQorICogYmFzaXMg aW4gdGhlIGFsbG9jYXRvcjsgaXQgaGFzIHRvIGhhcHBlbiB0aGVyZSByYXRoZXIgdGhhbiBoZXJl IGR1ZSB0bworICogcmVzcG9uc2UgdGltZSBjb25zaWRlcmF0aW9ucy4gIE1ha2UgdGhlIGNhbGwg aGVyZSBvbmNlIGV2ZXJ5IDEwIHBhc3NlcyBhcworICogd2VsbDsgdGhpcyByZWNsYWltcyB1bnVz ZWQgVU1BIGJ1ZmZlcnMgZXZlcnkgMTAgc2Vjb25kcyBvbiBhbiBpZGxlIHN5c3RlbQorICogYW5k IG1vcmUgZnJlcXVlbnRseSBpZiB0aGUgcmVjbGFpbSB0aHJlYWQgZ2V0cyB3b2tlbiB1cCBieSBs b3cgUkFNCisgKiBjb25kaXRpb25zLgorICovCisJCWlmICgoemlvX3VzZV91bWEpICYmIChhdXRv cmVhcCsrID09IDEwKSkgeworCQkJYXV0b3JlYXAgPSAwOworCQkJRFRSQUNFX1BST0JFKGFyY19f cmVjbGFpbV90aW1lZF9yZWFwKTsKKwkJCXJlYXBfYXJjX2NhY2hlcygpOworCQl9CisjZW5kaWYg LyogX0tFUk5FTCAqLworCiAJCWlmIChhcmNfcmVjbGFpbV9uZWVkZWQoKSkgewogCiAJCQlpZiAo YXJjX25vX2dyb3cpIHsKQEAgLTI4OTksNiArMjkzOCwxOSBAQCBhcmNfZ2V0X2RhdGFfYnVmKGFy Y19idWZfdCAqYnVmKQogCQkJYXJjX3NwYWNlX2NvbnN1bWUoc2l6ZSwgQVJDX1NQQUNFX0RBVEEp OwogCQl9IGVsc2UgewogCQkJQVNTRVJUKHR5cGUgPT0gQVJDX0JVRkNfREFUQSk7CisjaWZkZWYg X0tFUk5FTAorLyogS0QgMjAxNS0wMi0xMAorICogSXQgd291bGQgYmUgbmljZSBpZiB3ZSBjb3Vs ZCBsZWF2ZSB0aGlzIHRvIHRoZSBhcmNfcmVjbGFpbSB0aHJlYWQuCisgKiBVbmZvcnR1bmF0ZWx5 IHdlIGNhbm5vdDsgdGhlIHRlc3QgaGFzIHRvIGJlIGRvbmUgaGVyZSBhcyB3ZWxsLCBiZWNhdXNl CisgKiB1bmRlciBoZWF2eSBJL08gZGVtYW5kIHdlIGNhbiBncmFiIGVub3VnaCBSQU0gZmFzdCBl bm91Z2ggdG8gaW5kdWNlCisgKiBuYXN0eSBvc2NpbGxhdGlvbiBwcm9ibGVtcy4gIEZvcnR1bmF0 ZWx5IHdlIG9ubHkgbmVlZCB0byBjYWxsIHRoaXMgd2hlbgorICogdGhlIHN5c3RlbSBpcyB1bmRl ciByZWFzb25hYmx5LXNldmVyZSBtZW1vcnkgc3RyZXNzLgorICovCisJCQlpZiAoemlvX3VzZV91 bWEgJiYgKHB0b2IoY250LnZfZnJlZV9jb3VudCkgKyBzaXplIDwgcHRvYihjbnQudl9mcmVlX3Rh cmdldCkpKSB7CisJCQkJRFRSQUNFX1BST0JFMyhhcmNfX2FsbG9jX2xvd21lbV9yZWFwLCBpbnQs IGNudC52X2ZyZWVfY291bnQsIGludCwgc2l6ZSwgaW50LCBjbnQudl9mcmVlX3RhcmdldCk7CisJ CQkJcmVhcF9hcmNfY2FjaGVzKCk7CisJCQl9CisjZW5kaWYgLyogX0tFUk5FTCAqLwogCQkJYnVm LT5iX2RhdGEgPSB6aW9fZGF0YV9idWZfYWxsb2Moc2l6ZSk7CiAJCQlBUkNTVEFUX0lOQ1IoYXJj c3RhdF9kYXRhX3NpemUsIHNpemUpOwogCQkJYXRvbWljX2FkZF82NCgmYXJjX3NpemUsIHNpemUp OwpJbmRleDogY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90 eC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2Zz L3pmcy9kbXVfdHguYwkocmV2aXNpb24gMjg1NjAyKQorKysgY2RkbC9jb250cmliL29wZW5zb2xh cmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90eC5jCSh3b3JraW5nIGNvcHkpCkBAIC00Miw2ICs0 Miw4IEBACiB0eXBlZGVmIHZvaWQgKCpkbXVfdHhfaG9sZF9mdW5jX3QpKGRtdV90eF90ICp0eCwg c3RydWN0IGRub2RlICpkbiwKICAgICB1aW50NjRfdCBhcmcxLCB1aW50NjRfdCBhcmcyKTsKIAor ZXh0ZXJuCWludAl6aW9fdXNlX3VtYTsJLyogTmVlZHMgdG8gYmUgdmlzaWJsZTsgRE8gTk9UIE1P RElGWSEgKi8KK2ludAl6ZnNfZHluYW1pY193cml0ZV9idWZmZXIgPSAxOwkvKiBEeW5hbWljYWxs eSB0dW5lIHdyaXRlcyAqLwogCiBkbXVfdHhfdCAqCiBkbXVfdHhfY3JlYXRlX2RkKGRzbF9kaXJf dCAqZGQpCkBAIC0xMDU4LDcgKzEwNjAsNyBAQCBkbXVfdHhfZGVsYXkoZG11X3R4X3QgKnR4LCB1 aW50NjRfdCBkaXJ0eSkKIHsKIAlkc2xfcG9vbF90ICpkcCA9IHR4LT50eF9wb29sOwogCXVpbnQ2 NF90IGRlbGF5X21pbl9ieXRlcyA9Ci0JICAgIHpmc19kaXJ0eV9kYXRhX21heCAqIHpmc19kZWxh eV9taW5fZGlydHlfcGVyY2VudCAvIDEwMDsKKwkgICAgemZzX2RpcnR5X2RhdGFfbWF4X2ludGVy bmFsICogemZzX2RlbGF5X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOwogCWhydGltZV90IHdha2V1 cCwgbWluX3R4X3RpbWUsIG5vdzsKIAogCWlmIChkaXJ0eSA8PSBkZWxheV9taW5fYnl0ZXMpCkBA IC0xMDcwLDExICsxMDcyLDExIEBAIGRtdV90eF9kZWxheShkbXVfdHhfdCAqdHgsIHVpbnQ2NF90 IGRpcnR5KQogCSAqIGhhdmUgdG8gaGFuZGxlIHRoZSBjYXNlIG9mIGl0IGJlaW5nID49IHRoZSBt YXgsIHdoaWNoIGNvdWxkCiAJICogY2F1c2UgYSBkaXZpZGUtYnktemVybyBpZiBpdCdzID09IHRo ZSBtYXguCiAJICovCi0JQVNTRVJUM1UoZGlydHksIDwsIHpmc19kaXJ0eV9kYXRhX21heCk7CisJ QVNTRVJUM1UoZGlydHksIDwsIHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCk7CiAKIAlub3cg PSBnZXRocnRpbWUoKTsKIAltaW5fdHhfdGltZSA9IHpmc19kZWxheV9zY2FsZSAqCi0JICAgIChk aXJ0eSAtIGRlbGF5X21pbl9ieXRlcykgLyAoemZzX2RpcnR5X2RhdGFfbWF4IC0gZGlydHkpOwor CSAgICAoZGlydHkgLSBkZWxheV9taW5fYnl0ZXMpIC8gKHpmc19kaXJ0eV9kYXRhX21heF9pbnRl cm5hbCAtIGRpcnR5KTsKIAlpZiAobm93ID4gdHgtPnR4X3N0YXJ0ICsgbWluX3R4X3RpbWUpCiAJ CXJldHVybjsKIApAQCAtMTI3OSw2ICsxMjgxLDcgQEAgaW50CiBkbXVfdHhfYXNzaWduKGRtdV90 eF90ICp0eCwgdHhnX2hvd190IHR4Z19ob3cpCiB7CiAJaW50IGVycjsKKwlzdGF0aWMJdWludDY0 X3QJbGFzdF9tYXg7CiAKIAlBU1NFUlQodHgtPnR4X3R4ZyA9PSAwKTsKIAlBU1NFUlQodHhnX2hv dyA9PSBUWEdfV0FJVCB8fCB0eGdfaG93ID09IFRYR19OT1dBSVQgfHwKQEAgLTEyOTEsNiArMTI5 NCw0MiBAQCBkbXVfdHhfYXNzaWduKGRtdV90eF90ICp0eCwgdHhnX2hvd190IHR4Z19ob3cpCiAJ aWYgKHR4Z19ob3cgPT0gVFhHX1dBSVRFRCkKIAkJdHgtPnR4X3dhaXRlZCA9IEJfVFJVRTsKIAor I2lmZGVmIF9LRVJORUwKKwkvKgorCSAqIEtEIDIwMTQtMDktMjIKKwkgKiBJZiBVTUEgaXMgZW5h YmxlZCBpdCBjYW4gb25seSByZXR1cm4gYSBwcmV2aW91c2x5LXVzZWQgYmxvY2sKKwkgKiBvZiBp ZGVudGljYWwgc2l6ZSB0byB3aGF0IGl0IGhhZCBvdXQgYmVmb3JlLiAgSWYgaXQncyBub3QgdGhl CisJICogc2FtZSBzaXplIGl0IHdpbGwgYWxsb2NhdGUgYSBuZXcgb25lLiAgVGhpcyBpcyBhIHBy b2JsZW0gYmVjYXVzZQorCSAqIGRpcnR5X2RhdGFfbWF4IGlzIHRoZSB0b3RhbCBkaXJ0eSB3cml0 ZSBkYXRhIGFsbG93ZWQgb3V0IGF0IGFueQorCSAqIGdpdmVuIHRpbWUsIGJ1dCB3aXRoIFVNQSBv biB0aGF0IGNhbiBtdWx0aXBseSBieSB0aGUgbnVtYmVyIG9mCisJICogZGlmZmVyZW50IGJsb2Nr IHNpemVzICghISkgcmVxdWVzdGVkIGluIHRlcm1zIG9mIGZyZWUgUkFNIHRoYXQKKwkgKiBpcyBs ZWZ0IGFsbG9jYXRlZCBidXQgdW51c2VkLiAgRm9yIHRoaXMgcmVhc29uIG5ldmVyIGFsbG93CisJ ICogZGlydHlfZGF0YV9tYXggdG8gZXhjZWVkIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gdGhlIHBh Z2luZworCSAqIHRocmVzaG9sZCBhbmQgdGhlIGN1cnJlbnQgZnJlZSBtZW1vcnksIHdpdGggYSBt aW5pbXVtIG9mIDI1Nk1CLgorCSAqIFRoaXMgdGhyb3R0bGVzICJidXJzdCIgYWxsb2NhdGlvbnMg YW5kIHByZXZlbnRzIHRoZSBzeXN0ZW0gZnJvbQorCSAqIGNob2tpbmcgZHVyaW5nIHRpbWVzIG9m IGhpZ2ggd3JpdGUgSS9PIGRlbWFuZC4KKwkgKgorCSAqIFdlIGFsbG93IHRoaXMgdG8gYmUgdHVy bmVkIG9mZiBpZiB5b3Ugd2FudCB3aXRoCisJICogInZmcy56ZnNfZHluYW1pY193cml0ZV9idWZm ZXI9MCIsIHdoaWNoIGNhbiBiZSBkb25lIGluIHJlYWwgdGltZS4KKwkgKgorCSAqIE5vdGUgdGhh dCB3ZSB3b3JrIG9uIHRoZSB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgdmFyaWFibGUsCisJ ICogYmVjYXVzZSB0aGUgdXNlciBtYXkgc2V0IHpmc19kaXJ0eV9kYXRhX21heCBoaW1zZWxmIGFu ZCB3ZSBtdXN0CisJICogbXVzdCBob25vciB0aGF0IGFzIGEgaGFyZCBjYXAgc28gaXQgcmVtYWlu cyBhIHVzYWJsZSB0dW5hYmxlIHZhbHVlLgorCSAqLworCWlmICh6aW9fdXNlX3VtYSAmIHpmc19k eW5hbWljX3dyaXRlX2J1ZmZlcikgeworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSAx IDw8IDI4OworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBNQVgoemZzX2RpcnR5X2Rh dGFfbWF4X2ludGVybmFsLCBwdG9iKGNudC52X2ZyZWVfY291bnQgLSBjbnQudl9mcmVlX3Rhcmdl dCkpOworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBNSU4oemZzX2RpcnR5X2RhdGFf bWF4X2ludGVybmFsLCB6ZnNfZGlydHlfZGF0YV9tYXgpOworCQl6ZnNfZGlydHlfZGF0YV9tYXhf aW50ZXJuYWwgPSBNSU4oemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsLCB6ZnNfZGlydHlfZGF0 YV9tYXhfbWF4KTsKKwkJaWYgKGxhc3RfbWF4ICE9ICh6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJu YWwgLyAoMTAyNCAqIDEwMjQpKSkgeworCQkJbGFzdF9tYXggPSB6ZnNfZGlydHlfZGF0YV9tYXhf aW50ZXJuYWwgLyAoMTAyNCAqIDEwMjQpOworCQkJRFRSQUNFX1BST0JFMShkbXVfX3R4X2RpcnR5 LCB1aW50NjRfdCwgbGFzdF9tYXgpOworCQl9CisJfSBlbHNlIHsKKwkJemZzX2RpcnR5X2RhdGFf bWF4X2ludGVybmFsID0gemZzX2RpcnR5X2RhdGFfbWF4OworCX0KKyNlbmRpZiAvKiBfS0VSTkVM ICovCisKIAl3aGlsZSAoKGVyciA9IGRtdV90eF90cnlfYXNzaWduKHR4LCB0eGdfaG93KSkgIT0g MCkgewogCQlkbXVfdHhfdW5hc3NpZ24odHgpOwogCkBAIC0xMzIxLDcgKzEzNjAsNyBAQCBkbXVf dHhfd2FpdChkbXVfdHhfdCAqdHgpCiAJCSAqIHNwYWNlLgogCQkgKi8KIAkJbXV0ZXhfZW50ZXIo JmRwLT5kcF9sb2NrKTsKLQkJd2hpbGUgKGRwLT5kcF9kaXJ0eV90b3RhbCA+PSB6ZnNfZGlydHlf ZGF0YV9tYXgpCisJCXdoaWxlIChkcC0+ZHBfZGlydHlfdG90YWwgPj0gemZzX2RpcnR5X2RhdGFf bWF4X2ludGVybmFsKQogCQkJY3Zfd2FpdCgmZHAtPmRwX3NwYWNlYXZhaWxfY3YsICZkcC0+ZHBf bG9jayk7CiAJCXVpbnQ2NF90IGRpcnR5ID0gZHAtPmRwX2RpcnR5X3RvdGFsOwogCQltdXRleF9l eGl0KCZkcC0+ZHBfbG9jayk7CkluZGV4OiBjZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2Nv bW1vbi9mcy96ZnMvZHNsX3Bvb2wuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNv bGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZHNsX3Bvb2wuYwkocmV2aXNpb24gMjg1NjAyKQorKysg Y2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RzbF9wb29sLmMJKHdv cmtpbmcgY29weSkKQEAgLTk3LDggKzk3LDExIEBACiAvKgogICogemZzX2RpcnR5X2RhdGFfbWF4 IHdpbGwgYmUgc2V0IHRvIHpmc19kaXJ0eV9kYXRhX21heF9wZXJjZW50JSBvZiBhbGwgbWVtb3J5 LAogICogY2FwcGVkIGF0IHpmc19kaXJ0eV9kYXRhX21heF9tYXguICBJdCBjYW4gYWxzbyBiZSBv dmVycmlkZGVuIGluIC9ldGMvc3lzdGVtLgorICogV2UgYWxzbyBkeW5hbWljYWxseSB0dW5lIGR1 cmluZyBsb3cgbWVtb3J5LCBob25vcmluZyB0aGUgc3lzY3RsIHNldCwgc28KKyAqIGludGVybmFs IGNvbXBhcmlzb25zIGFyZSBhZ2FpbnN0IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbC4KICAq LwogdWludDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4OwordWludDY0X3QgemZzX2RpcnR5X2RhdGFf bWF4X2ludGVybmFsOwogdWludDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4X21heCA9IDRVTEwgKiAx MDI0ICogMTAyNCAqIDEwMjQ7CiBpbnQgemZzX2RpcnR5X2RhdGFfbWF4X3BlcmNlbnQgPSAxMDsK IApAQCAtNTQ3LDcgKzU1MCw3IEBAIGRzbF9wb29sX2RpcnR5X2RlbHRhKGRzbF9wb29sX3QgKmRw LCBpbnQ2NF90IGRlbHRhCiAJICogTm90ZTogd2Ugc2lnbmFsIGV2ZW4gd2hlbiBpbmNyZWFzaW5n IGRwX2RpcnR5X3RvdGFsLgogCSAqIFRoaXMgZW5zdXJlcyBmb3J3YXJkIHByb2dyZXNzIC0tIGVh Y2ggdGhyZWFkIHdha2VzIHRoZSBuZXh0IHdhaXRlci4KIAkgKi8KLQlpZiAoZHAtPmRwX2RpcnR5 X3RvdGFsIDw9IHpmc19kaXJ0eV9kYXRhX21heCkKKwlpZiAoZHAtPmRwX2RpcnR5X3RvdGFsIDw9 IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCkKIAkJY3Zfc2lnbmFsKCZkcC0+ZHBfc3BhY2Vh dmFpbF9jdik7CiB9CiAKQEAgLTcyNiw3ICs3MjksNyBAQCBib29sZWFuX3QKIGRzbF9wb29sX25l ZWRfZGlydHlfZGVsYXkoZHNsX3Bvb2xfdCAqZHApCiB7CiAJdWludDY0X3QgZGVsYXlfbWluX2J5 dGVzID0KLQkgICAgemZzX2RpcnR5X2RhdGFfbWF4ICogemZzX2RlbGF5X21pbl9kaXJ0eV9wZXJj ZW50IC8gMTAwOworCSAgICB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgKiB6ZnNfZGVsYXlf bWluX2RpcnR5X3BlcmNlbnQgLyAxMDA7CiAJYm9vbGVhbl90IHJ2OwogCiAJbXV0ZXhfZW50ZXIo JmRwLT5kcF9sb2NrKTsKSW5kZXg6IGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9u L2ZzL3pmcy9zeXMvZHNsX3Bvb2wuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNv bGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvc3lzL2RzbF9wb29sLmgJKHJldmlzaW9uIDI4NTYwMikK KysrIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9zeXMvZHNsX3Bv b2wuaAkod29ya2luZyBjb3B5KQpAQCAtNTAsNiArNTAsNyBAQCBzdHJ1Y3QgZG11X3R4Owogc3Ry dWN0IGRzbF9zY2FuOwogCiBleHRlcm4gdWludDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4OworZXh0 ZXJuIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbDsKIGV4dGVybiB1aW50NjRf dCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4OwogZXh0ZXJuIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRh X3N5bmM7CiBleHRlcm4gaW50IHpmc19kaXJ0eV9kYXRhX21heF9wZXJjZW50OwpJbmRleDogY2Rk bC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3ppby5jCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy96aW8uYwkocmV2 aXNpb24gMjg1NjAyKQorKysgY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMv emZzL3ppby5jCSh3b3JraW5nIGNvcHkpCkBAIC00MywxMCArNDMsMTMgQEAKIAogU1lTQ1RMX0RF Q0woX3Zmc196ZnMpOwogU1lTQ1RMX05PREUoX3Zmc196ZnMsIE9JRF9BVVRPLCB6aW8sIENUTEZM QUdfUlcsIDAsICJaRlMgWklPIik7CisvKiBLRCAyMDE1LTA3LTE1IENoYW5nZSBjbGFzcyB0byAi aW50IiBmcm9tICJzdGF0aWMgaW50IiBhcyB3ZSByZWZlcmVuY2UgCisgKiB0aGlzIGFzIGFuIGV4 dGVybiBlbHNld2hlcmUKKyAqLwogI2lmIGRlZmluZWQoX19hbWQ2NF9fKQotc3RhdGljIGludCB6 aW9fdXNlX3VtYSA9IDE7CitpbnQgemlvX3VzZV91bWEgPSAxOwogI2Vsc2UKLXN0YXRpYyBpbnQg emlvX3VzZV91bWEgPSAwOworaW50IHppb191c2VfdW1hID0gMDsKICNlbmRpZgogVFVOQUJMRV9J TlQoInZmcy56ZnMuemlvLnVzZV91bWEiLCAmemlvX3VzZV91bWEpOwogU1lTQ1RMX0lOVChfdmZz X3pmc196aW8sIE9JRF9BVVRPLCB1c2VfdW1hLCBDVExGTEFHX1JEVFVOLCAmemlvX3VzZV91bWEs IDAsCg== 159688 2015-08-09 11:56:42 +0000 2015-08-15 16:51:55 +0000 ARC Refactor / UMA Cleardown / DMU_TX dynamic against head after r263620 patch.head.r263620 text/plain 11482 junchoon SW5kZXg6IGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMv YXJjLmMJKHJldmlzaW9uIDI4NTYwMikKKysrIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMv Y29tbW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMTkwLDYgKzE5MCwxNSBAQCBz dGF0aWMgaW50IGFyY19kZWFkOwogZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hfZGlzYWJsZTsKIAog LyoKKyAqIEtEIDIwMTUtMDItMTAKKyAqIFdlIGhhdmUgdG8gYmUgYWJsZSB0byB0ZXN0IGZvciBV SU8gdXNlIGluc2lkZSB0aGUgYXJjIGFsbG9jYXRvci4KKyAqIE5PVEU6IERPIE5PVCBNT0RJRlkg SEVSRSEKKyAqLworZXh0ZXJuIGludCB6aW9fdXNlX3VtYTsKK2V4dGVybiBpbnQgemZzX2R5bmFt aWNfd3JpdGVfYnVmZmVyOworCisKKy8qCiAgKiBUaGUgYXJjIGhhcyBmaWxsZWQgYXZhaWxhYmxl IG1lbW9yeSBhbmQgaGFzIG5vdyB3YXJtZWQgdXAuCiAgKi8KIHN0YXRpYyBib29sZWFuX3QgYXJj X3dhcm07CkBAIC0yMTIsNyArMjIxLDcgQEAgc3RhdGljIHZvaWQKIGFyY19mcmVlX3RhcmdldF9p bml0KHZvaWQgKnVudXNlZCBfX3VudXNlZCkKIHsKIAotCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2 bV9wYWdlb3V0X3dha2V1cF90aHJlc2g7CisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2Vv dXRfd2FrZXVwX3RocmVzaCArICgodm1fY250LnZfZnJlZV90YXJnZXQgLSB2bV9wYWdlb3V0X3dh a2V1cF90aHJlc2gpIC8gMik7CiB9CiBTWVNJTklUKGFyY19mcmVlX3RhcmdldF9pbml0LCBTSV9T VUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRFUl9BTlksCiAgICAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQs IE5VTEwpOwpAQCAtMjMzLDcgKzI0Miw5IEBAIFNZU0NUTF9VUVVBRChfdmZzX3pmcywgT0lEX0FV VE8sIGFyY19hdmVyYWdlX2Jsb2NrCiBTWVNDVExfSU5UKF92ZnNfemZzLCBPSURfQVVUTywgYXJj X3Nocmlua19zaGlmdCwgQ1RMRkxBR19SVywKICAgICAmYXJjX3Nocmlua19zaGlmdCwgMCwKICAg ICAibG9nMihmcmFjdGlvbiBvZiBhcmMgdG8gcmVjbGFpbSkiKTsKLQorU1lTQ1RMX0lOVChfdmZz X3pmcywgT0lEX0FVVE8sIGR5bmFtaWNfd3JpdGVfYnVmZmVyLCBDVExGTEFHX1JXVFVOLAorICAg ICZ6ZnNfZHluYW1pY193cml0ZV9idWZmZXIsIDAsCisgICAgIkR5bmFtaWNhbGx5IHJlc3RyaWN0 IGRpcnR5IGRhdGEgd2hlbiBtZW1vcnkgaXMgbG93Iik7CiAvKgogICogV2UgZG9uJ3QgaGF2ZSBh IHR1bmFibGUgZm9yIGFyY19mcmVlX3RhcmdldCBkdWUgdG8gdGhlIGRlcGVuZGVuY3kgb24KICAq IHBhZ2VkYWVtb24gaW5pdGlhbGlzYXRpb24uCkBAIC0yNjQ1LDYgKzI2NTYsMjggQEAgZXh0ZXJu IGttZW1fY2FjaGVfdAkqemlvX2J1Zl9jYWNoZVtdOwogZXh0ZXJuIGttZW1fY2FjaGVfdAkqemlv X2RhdGFfYnVmX2NhY2hlW107CiBleHRlcm4ga21lbV9jYWNoZV90CSpyYW5nZV9zZWdfY2FjaGU7 CiAKK3N0YXRpYyB2b2lkIF9fdXNlZAorcmVhcF9hcmNfY2FjaGVzKCkKK3sKKwlzaXplX3QgICAg ICAgICAgaTsKKwlrbWVtX2NhY2hlX3QgICAgICAgICAgICAqcHJldl9jYWNoZSA9IE5VTEw7CisJ a21lbV9jYWNoZV90ICAgICAgICAgICAgKnByZXZfZGF0YV9jYWNoZSA9IE5VTEw7CisKKwlmb3Ig KGkgPSAwOyBpIDwgU1BBX01BWEJMT0NLU0laRSA+PiBTUEFfTUlOQkxPQ0tTSElGVDsgaSsrKSB7 CisJCWlmICh6aW9fYnVmX2NhY2hlW2ldICE9IHByZXZfY2FjaGUpIHsKKwkJCXByZXZfY2FjaGUg PSB6aW9fYnVmX2NhY2hlW2ldOworCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6aW9fYnVmX2NhY2hl W2ldKTsKKwkJfQorCQlpZiAoemlvX2RhdGFfYnVmX2NhY2hlW2ldICE9IHByZXZfZGF0YV9jYWNo ZSkgeworCQkJcHJldl9kYXRhX2NhY2hlID0gemlvX2RhdGFfYnVmX2NhY2hlW2ldOworCQkJa21l bV9jYWNoZV9yZWFwX25vdyh6aW9fZGF0YV9idWZfY2FjaGVbaV0pOworCQl9CisJfQorCWttZW1f Y2FjaGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKKwlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9jYWNo ZSk7CisJa21lbV9jYWNoZV9yZWFwX25vdyhyYW5nZV9zZWdfY2FjaGUpOworfQorCiBzdGF0aWMg X19ub2lubGluZSB2b2lkCiBhcmNfa21lbV9yZWFwX25vdyhhcmNfcmVjbGFpbV9zdHJhdGVneV90 IHN0cmF0KQogewpAQCAtMjY3NiwxOSArMjcwOSw3IEBAIGFyY19rbWVtX3JlYXBfbm93KGFyY19y ZWNsYWltX3N0cmF0ZWd5X3Qgc3RyYXQpCiAJaWYgKHN0cmF0ID09IEFSQ19SRUNMQUlNX0FHR1Ip CiAJCWFyY19zaHJpbmsoKTsKIAotCWZvciAoaSA9IDA7IGkgPCBTUEFfTUFYQkxPQ0tTSVpFID4+ IFNQQV9NSU5CTE9DS1NISUZUOyBpKyspIHsKLQkJaWYgKHppb19idWZfY2FjaGVbaV0gIT0gcHJl dl9jYWNoZSkgewotCQkJcHJldl9jYWNoZSA9IHppb19idWZfY2FjaGVbaV07Ci0JCQlrbWVtX2Nh Y2hlX3JlYXBfbm93KHppb19idWZfY2FjaGVbaV0pOwotCQl9Ci0JCWlmICh6aW9fZGF0YV9idWZf Y2FjaGVbaV0gIT0gcHJldl9kYXRhX2NhY2hlKSB7Ci0JCQlwcmV2X2RhdGFfY2FjaGUgPSB6aW9f ZGF0YV9idWZfY2FjaGVbaV07Ci0JCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19kYXRhX2J1Zl9j YWNoZVtpXSk7Ci0JCX0KLQl9Ci0Ja21lbV9jYWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOwotCWtt ZW1fY2FjaGVfcmVhcF9ub3coaGRyX2NhY2hlKTsKLQlrbWVtX2NhY2hlX3JlYXBfbm93KHJhbmdl X3NlZ19jYWNoZSk7CisJcmVhcF9hcmNfY2FjaGVzKCk7CiAKICNpZmRlZiBzdW4KIAkvKgpAQCAt MjcwNywxMSArMjcyOCwyOSBAQCBhcmNfcmVjbGFpbV90aHJlYWQodm9pZCAqZHVtbXkgX191bnVz ZWQpCiAJY2xvY2tfdAkJCWdyb3d0aW1lID0gMDsKIAlhcmNfcmVjbGFpbV9zdHJhdGVneV90CWxh c3RfcmVjbGFpbSA9IEFSQ19SRUNMQUlNX0NPTlM7CiAJY2FsbGJfY3ByX3QJCWNwcjsKKwlpbnQJ CQlhdXRvcmVhcCA9IDA7CiAKIAlDQUxMQl9DUFJfSU5JVCgmY3ByLCAmYXJjX3JlY2xhaW1fdGhy X2xvY2ssIGNhbGxiX2dlbmVyaWNfY3ByLCBGVEFHKTsKIAogCW11dGV4X2VudGVyKCZhcmNfcmVj bGFpbV90aHJfbG9jayk7CiAJd2hpbGUgKGFyY190aHJlYWRfZXhpdCA9PSAwKSB7CisKKyNpZmRl ZiBfS0VSTkVMCisvKiBLRCAyMDE1LTAyLTEwCisgKiBQcm90ZWN0IGFnYWluc3QgVU1BIGZyZWUg bWVtb3J5IGJsb2F0LiAgV2UgYWxyZWFkeSBkbyB0aGlzIG9uIGEgbG93LW1lbW9yeQorICogYmFz aXMgaW4gdGhlIGFsbG9jYXRvcjsgaXQgaGFzIHRvIGhhcHBlbiB0aGVyZSByYXRoZXIgdGhhbiBo ZXJlIGR1ZSB0bworICogcmVzcG9uc2UgdGltZSBjb25zaWRlcmF0aW9ucy4gIE1ha2UgdGhlIGNh bGwgaGVyZSBvbmNlIGV2ZXJ5IDEwIHBhc3NlcyBhcworICogd2VsbDsgdGhpcyByZWNsYWltcyB1 bnVzZWQgVU1BIGJ1ZmZlcnMgZXZlcnkgMTAgc2Vjb25kcyBvbiBhbiBpZGxlIHN5c3RlbQorICog YW5kIG1vcmUgZnJlcXVlbnRseSBpZiB0aGUgcmVjbGFpbSB0aHJlYWQgZ2V0cyB3b2tlbiB1cCBi eSBsb3cgUkFNCisgKiBjb25kaXRpb25zLgorICovCisJCWlmICgoemlvX3VzZV91bWEpICYmIChh dXRvcmVhcCsrID09IDEwKSkgeworCQkJYXV0b3JlYXAgPSAwOworCQkJRFRSQUNFX1BST0JFKGFy Y19fcmVjbGFpbV90aW1lZF9yZWFwKTsKKwkJCXJlYXBfYXJjX2NhY2hlcygpOworCQl9CisjZW5k aWYgLyogX0tFUk5FTCAqLworCiAJCWlmIChhcmNfcmVjbGFpbV9uZWVkZWQoKSkgewogCiAJCQlp ZiAoYXJjX25vX2dyb3cpIHsKQEAgLTI4OTksNiArMjkzOCwxOSBAQCBhcmNfZ2V0X2RhdGFfYnVm KGFyY19idWZfdCAqYnVmKQogCQkJYXJjX3NwYWNlX2NvbnN1bWUoc2l6ZSwgQVJDX1NQQUNFX0RB VEEpOwogCQl9IGVsc2UgewogCQkJQVNTRVJUKHR5cGUgPT0gQVJDX0JVRkNfREFUQSk7CisjaWZk ZWYgX0tFUk5FTAorLyogS0QgMjAxNS0wMi0xMAorICogSXQgd291bGQgYmUgbmljZSBpZiB3ZSBj b3VsZCBsZWF2ZSB0aGlzIHRvIHRoZSBhcmNfcmVjbGFpbSB0aHJlYWQuCisgKiBVbmZvcnR1bmF0 ZWx5IHdlIGNhbm5vdDsgdGhlIHRlc3QgaGFzIHRvIGJlIGRvbmUgaGVyZSBhcyB3ZWxsLCBiZWNh dXNlCisgKiB1bmRlciBoZWF2eSBJL08gZGVtYW5kIHdlIGNhbiBncmFiIGVub3VnaCBSQU0gZmFz dCBlbm91Z2ggdG8gaW5kdWNlCisgKiBuYXN0eSBvc2NpbGxhdGlvbiBwcm9ibGVtcy4gIEZvcnR1 bmF0ZWx5IHdlIG9ubHkgbmVlZCB0byBjYWxsIHRoaXMgd2hlbgorICogdGhlIHN5c3RlbSBpcyB1 bmRlciByZWFzb25hYmx5LXNldmVyZSBtZW1vcnkgc3RyZXNzLgorICovCisJCQlpZiAoemlvX3Vz ZV91bWEgJiYgKHB0b2Iodm1fY250LnZfZnJlZV9jb3VudCkgKyBzaXplIDwgcHRvYih2bV9jbnQu dl9mcmVlX3RhcmdldCkpKSB7CisJCQkJRFRSQUNFX1BST0JFMyhhcmNfX2FsbG9jX2xvd21lbV9y ZWFwLCBpbnQsIHZtX2NudC52X2ZyZWVfY291bnQsIGludCwgc2l6ZSwgaW50LCB2bV9jbnQudl9m cmVlX3RhcmdldCk7CisJCQkJcmVhcF9hcmNfY2FjaGVzKCk7CisJCQl9CisjZW5kaWYgLyogX0tF Uk5FTCAqLwogCQkJYnVmLT5iX2RhdGEgPSB6aW9fZGF0YV9idWZfYWxsb2Moc2l6ZSk7CiAJCQlB UkNTVEFUX0lOQ1IoYXJjc3RhdF9kYXRhX3NpemUsIHNpemUpOwogCQkJYXRvbWljX2FkZF82NCgm YXJjX3NpemUsIHNpemUpOwpJbmRleDogY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21t b24vZnMvemZzL2RtdV90eC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGNkZGwvY29udHJpYi9vcGVuc29sYXJp cy91dHMvY29tbW9uL2ZzL3pmcy9kbXVfdHguYwkocmV2aXNpb24gMjg1NjAyKQorKysgY2RkbC9j b250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90eC5jCSh3b3JraW5nIGNv cHkpCkBAIC00Miw2ICs0Miw4IEBACiB0eXBlZGVmIHZvaWQgKCpkbXVfdHhfaG9sZF9mdW5jX3Qp KGRtdV90eF90ICp0eCwgc3RydWN0IGRub2RlICpkbiwKICAgICB1aW50NjRfdCBhcmcxLCB1aW50 NjRfdCBhcmcyKTsKIAorZXh0ZXJuCWludAl6aW9fdXNlX3VtYTsJLyogTmVlZHMgdG8gYmUgdmlz aWJsZTsgRE8gTk9UIE1PRElGWSEgKi8KK2ludAl6ZnNfZHluYW1pY193cml0ZV9idWZmZXIgPSAx OwkvKiBEeW5hbWljYWxseSB0dW5lIHdyaXRlcyAqLwogCiBkbXVfdHhfdCAqCiBkbXVfdHhfY3Jl YXRlX2RkKGRzbF9kaXJfdCAqZGQpCkBAIC0xMDU4LDcgKzEwNjAsNyBAQCBkbXVfdHhfZGVsYXko ZG11X3R4X3QgKnR4LCB1aW50NjRfdCBkaXJ0eSkKIHsKIAlkc2xfcG9vbF90ICpkcCA9IHR4LT50 eF9wb29sOwogCXVpbnQ2NF90IGRlbGF5X21pbl9ieXRlcyA9Ci0JICAgIHpmc19kaXJ0eV9kYXRh X21heCAqIHpmc19kZWxheV9taW5fZGlydHlfcGVyY2VudCAvIDEwMDsKKwkgICAgemZzX2RpcnR5 X2RhdGFfbWF4X2ludGVybmFsICogemZzX2RlbGF5X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOwog CWhydGltZV90IHdha2V1cCwgbWluX3R4X3RpbWUsIG5vdzsKIAogCWlmIChkaXJ0eSA8PSBkZWxh eV9taW5fYnl0ZXMpCkBAIC0xMDcwLDExICsxMDcyLDExIEBAIGRtdV90eF9kZWxheShkbXVfdHhf dCAqdHgsIHVpbnQ2NF90IGRpcnR5KQogCSAqIGhhdmUgdG8gaGFuZGxlIHRoZSBjYXNlIG9mIGl0 IGJlaW5nID49IHRoZSBtYXgsIHdoaWNoIGNvdWxkCiAJICogY2F1c2UgYSBkaXZpZGUtYnktemVy byBpZiBpdCdzID09IHRoZSBtYXguCiAJICovCi0JQVNTRVJUM1UoZGlydHksIDwsIHpmc19kaXJ0 eV9kYXRhX21heCk7CisJQVNTRVJUM1UoZGlydHksIDwsIHpmc19kaXJ0eV9kYXRhX21heF9pbnRl cm5hbCk7CiAKIAlub3cgPSBnZXRocnRpbWUoKTsKIAltaW5fdHhfdGltZSA9IHpmc19kZWxheV9z Y2FsZSAqCi0JICAgIChkaXJ0eSAtIGRlbGF5X21pbl9ieXRlcykgLyAoemZzX2RpcnR5X2RhdGFf bWF4IC0gZGlydHkpOworCSAgICAoZGlydHkgLSBkZWxheV9taW5fYnl0ZXMpIC8gKHpmc19kaXJ0 eV9kYXRhX21heF9pbnRlcm5hbCAtIGRpcnR5KTsKIAlpZiAobm93ID4gdHgtPnR4X3N0YXJ0ICsg bWluX3R4X3RpbWUpCiAJCXJldHVybjsKIApAQCAtMTI3OSw2ICsxMjgxLDcgQEAgaW50CiBkbXVf dHhfYXNzaWduKGRtdV90eF90ICp0eCwgdHhnX2hvd190IHR4Z19ob3cpCiB7CiAJaW50IGVycjsK KwlzdGF0aWMJdWludDY0X3QJbGFzdF9tYXg7CiAKIAlBU1NFUlQodHgtPnR4X3R4ZyA9PSAwKTsK IAlBU1NFUlQodHhnX2hvdyA9PSBUWEdfV0FJVCB8fCB0eGdfaG93ID09IFRYR19OT1dBSVQgfHwK QEAgLTEyOTEsNiArMTI5NCw0MiBAQCBkbXVfdHhfYXNzaWduKGRtdV90eF90ICp0eCwgdHhnX2hv d190IHR4Z19ob3cpCiAJaWYgKHR4Z19ob3cgPT0gVFhHX1dBSVRFRCkKIAkJdHgtPnR4X3dhaXRl ZCA9IEJfVFJVRTsKIAorI2lmZGVmIF9LRVJORUwKKwkvKgorCSAqIEtEIDIwMTQtMDktMjIKKwkg KiBJZiBVTUEgaXMgZW5hYmxlZCBpdCBjYW4gb25seSByZXR1cm4gYSBwcmV2aW91c2x5LXVzZWQg YmxvY2sKKwkgKiBvZiBpZGVudGljYWwgc2l6ZSB0byB3aGF0IGl0IGhhZCBvdXQgYmVmb3JlLiAg SWYgaXQncyBub3QgdGhlCisJICogc2FtZSBzaXplIGl0IHdpbGwgYWxsb2NhdGUgYSBuZXcgb25l LiAgVGhpcyBpcyBhIHByb2JsZW0gYmVjYXVzZQorCSAqIGRpcnR5X2RhdGFfbWF4IGlzIHRoZSB0 b3RhbCBkaXJ0eSB3cml0ZSBkYXRhIGFsbG93ZWQgb3V0IGF0IGFueQorCSAqIGdpdmVuIHRpbWUs IGJ1dCB3aXRoIFVNQSBvbiB0aGF0IGNhbiBtdWx0aXBseSBieSB0aGUgbnVtYmVyIG9mCisJICog ZGlmZmVyZW50IGJsb2NrIHNpemVzICghISkgcmVxdWVzdGVkIGluIHRlcm1zIG9mIGZyZWUgUkFN IHRoYXQKKwkgKiBpcyBsZWZ0IGFsbG9jYXRlZCBidXQgdW51c2VkLiAgRm9yIHRoaXMgcmVhc29u IG5ldmVyIGFsbG93CisJICogZGlydHlfZGF0YV9tYXggdG8gZXhjZWVkIHRoZSBkaWZmZXJlbmNl IGJldHdlZW4gdGhlIHBhZ2luZworCSAqIHRocmVzaG9sZCBhbmQgdGhlIGN1cnJlbnQgZnJlZSBt ZW1vcnksIHdpdGggYSBtaW5pbXVtIG9mIDI1Nk1CLgorCSAqIFRoaXMgdGhyb3R0bGVzICJidXJz dCIgYWxsb2NhdGlvbnMgYW5kIHByZXZlbnRzIHRoZSBzeXN0ZW0gZnJvbQorCSAqIGNob2tpbmcg ZHVyaW5nIHRpbWVzIG9mIGhpZ2ggd3JpdGUgSS9PIGRlbWFuZC4KKwkgKgorCSAqIFdlIGFsbG93 IHRoaXMgdG8gYmUgdHVybmVkIG9mZiBpZiB5b3Ugd2FudCB3aXRoCisJICogInZmcy56ZnNfZHlu YW1pY193cml0ZV9idWZmZXI9MCIsIHdoaWNoIGNhbiBiZSBkb25lIGluIHJlYWwgdGltZS4KKwkg KgorCSAqIE5vdGUgdGhhdCB3ZSB3b3JrIG9uIHRoZSB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJu YWwgdmFyaWFibGUsCisJICogYmVjYXVzZSB0aGUgdXNlciBtYXkgc2V0IHpmc19kaXJ0eV9kYXRh X21heCBoaW1zZWxmIGFuZCB3ZSBtdXN0CisJICogbXVzdCBob25vciB0aGF0IGFzIGEgaGFyZCBj YXAgc28gaXQgcmVtYWlucyBhIHVzYWJsZSB0dW5hYmxlIHZhbHVlLgorCSAqLworCWlmICh6aW9f dXNlX3VtYSAmIHpmc19keW5hbWljX3dyaXRlX2J1ZmZlcikgeworCQl6ZnNfZGlydHlfZGF0YV9t YXhfaW50ZXJuYWwgPSAxIDw8IDI4OworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBN QVgoemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsLCBwdG9iKHZtX2NudC52X2ZyZWVfY291bnQg LSB2bV9jbnQudl9mcmVlX3RhcmdldCkpOworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwg PSBNSU4oemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsLCB6ZnNfZGlydHlfZGF0YV9tYXgpOwor CQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBNSU4oemZzX2RpcnR5X2RhdGFfbWF4X2lu dGVybmFsLCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4KTsKKwkJaWYgKGxhc3RfbWF4ICE9ICh6ZnNf ZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgLyAoMTAyNCAqIDEwMjQpKSkgeworCQkJbGFzdF9tYXgg PSB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgLyAoMTAyNCAqIDEwMjQpOworCQkJRFRSQUNF X1BST0JFMShkbXVfX3R4X2RpcnR5LCB1aW50NjRfdCwgbGFzdF9tYXgpOworCQl9CisJfSBlbHNl IHsKKwkJemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsID0gemZzX2RpcnR5X2RhdGFfbWF4Owor CX0KKyNlbmRpZiAvKiBfS0VSTkVMICovCisKIAl3aGlsZSAoKGVyciA9IGRtdV90eF90cnlfYXNz aWduKHR4LCB0eGdfaG93KSkgIT0gMCkgewogCQlkbXVfdHhfdW5hc3NpZ24odHgpOwogCkBAIC0x MzIxLDcgKzEzNjAsNyBAQCBkbXVfdHhfd2FpdChkbXVfdHhfdCAqdHgpCiAJCSAqIHNwYWNlLgog CQkgKi8KIAkJbXV0ZXhfZW50ZXIoJmRwLT5kcF9sb2NrKTsKLQkJd2hpbGUgKGRwLT5kcF9kaXJ0 eV90b3RhbCA+PSB6ZnNfZGlydHlfZGF0YV9tYXgpCisJCXdoaWxlIChkcC0+ZHBfZGlydHlfdG90 YWwgPj0gemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsKQogCQkJY3Zfd2FpdCgmZHAtPmRwX3Nw YWNlYXZhaWxfY3YsICZkcC0+ZHBfbG9jayk7CiAJCXVpbnQ2NF90IGRpcnR5ID0gZHAtPmRwX2Rp cnR5X3RvdGFsOwogCQltdXRleF9leGl0KCZkcC0+ZHBfbG9jayk7CkluZGV4OiBjZGRsL2NvbnRy aWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZHNsX3Bvb2wuYwo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBjZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZHNsX3Bvb2wuYwko cmV2aXNpb24gMjg1NjAyKQorKysgY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24v ZnMvemZzL2RzbF9wb29sLmMJKHdvcmtpbmcgY29weSkKQEAgLTk3LDggKzk3LDExIEBACiAvKgog ICogemZzX2RpcnR5X2RhdGFfbWF4IHdpbGwgYmUgc2V0IHRvIHpmc19kaXJ0eV9kYXRhX21heF9w ZXJjZW50JSBvZiBhbGwgbWVtb3J5LAogICogY2FwcGVkIGF0IHpmc19kaXJ0eV9kYXRhX21heF9t YXguICBJdCBjYW4gYWxzbyBiZSBvdmVycmlkZGVuIGluIC9ldGMvc3lzdGVtLgorICogV2UgYWxz byBkeW5hbWljYWxseSB0dW5lIGR1cmluZyBsb3cgbWVtb3J5LCBob25vcmluZyB0aGUgc3lzY3Rs IHNldCwgc28KKyAqIGludGVybmFsIGNvbXBhcmlzb25zIGFyZSBhZ2FpbnN0IHpmc19kaXJ0eV9k YXRhX21heF9pbnRlcm5hbC4KICAqLwogdWludDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4OwordWlu dDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsOwogdWludDY0X3QgemZzX2RpcnR5X2Rh dGFfbWF4X21heCA9IDRVTEwgKiAxMDI0ICogMTAyNCAqIDEwMjQ7CiBpbnQgemZzX2RpcnR5X2Rh dGFfbWF4X3BlcmNlbnQgPSAxMDsKIApAQCAtNTQ3LDcgKzU1MCw3IEBAIGRzbF9wb29sX2RpcnR5 X2RlbHRhKGRzbF9wb29sX3QgKmRwLCBpbnQ2NF90IGRlbHRhCiAJICogTm90ZTogd2Ugc2lnbmFs IGV2ZW4gd2hlbiBpbmNyZWFzaW5nIGRwX2RpcnR5X3RvdGFsLgogCSAqIFRoaXMgZW5zdXJlcyBm b3J3YXJkIHByb2dyZXNzIC0tIGVhY2ggdGhyZWFkIHdha2VzIHRoZSBuZXh0IHdhaXRlci4KIAkg Ki8KLQlpZiAoZHAtPmRwX2RpcnR5X3RvdGFsIDw9IHpmc19kaXJ0eV9kYXRhX21heCkKKwlpZiAo ZHAtPmRwX2RpcnR5X3RvdGFsIDw9IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCkKIAkJY3Zf c2lnbmFsKCZkcC0+ZHBfc3BhY2VhdmFpbF9jdik7CiB9CiAKQEAgLTcyNiw3ICs3MjksNyBAQCBi b29sZWFuX3QKIGRzbF9wb29sX25lZWRfZGlydHlfZGVsYXkoZHNsX3Bvb2xfdCAqZHApCiB7CiAJ dWludDY0X3QgZGVsYXlfbWluX2J5dGVzID0KLQkgICAgemZzX2RpcnR5X2RhdGFfbWF4ICogemZz X2RlbGF5X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOworCSAgICB6ZnNfZGlydHlfZGF0YV9tYXhf aW50ZXJuYWwgKiB6ZnNfZGVsYXlfbWluX2RpcnR5X3BlcmNlbnQgLyAxMDA7CiAJYm9vbGVhbl90 IHJ2OwogCiAJbXV0ZXhfZW50ZXIoJmRwLT5kcF9sb2NrKTsKSW5kZXg6IGNkZGwvY29udHJpYi9v cGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9zeXMvZHNsX3Bvb2wuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBjZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvc3lzL2RzbF9wb29s LmgJKHJldmlzaW9uIDI4NTYwMikKKysrIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29t bW9uL2ZzL3pmcy9zeXMvZHNsX3Bvb2wuaAkod29ya2luZyBjb3B5KQpAQCAtNTAsNiArNTAsNyBA QCBzdHJ1Y3QgZG11X3R4Owogc3RydWN0IGRzbF9zY2FuOwogCiBleHRlcm4gdWludDY0X3QgemZz X2RpcnR5X2RhdGFfbWF4OworZXh0ZXJuIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heF9pbnRl cm5hbDsKIGV4dGVybiB1aW50NjRfdCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4OwogZXh0ZXJuIHVp bnQ2NF90IHpmc19kaXJ0eV9kYXRhX3N5bmM7CiBleHRlcm4gaW50IHpmc19kaXJ0eV9kYXRhX21h eF9wZXJjZW50OwpJbmRleDogY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMv emZzL3ppby5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29t bW9uL2ZzL3pmcy96aW8uYwkocmV2aXNpb24gMjg1NjAyKQorKysgY2RkbC9jb250cmliL29wZW5z b2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3ppby5jCSh3b3JraW5nIGNvcHkpCkBAIC00MywxMCAr NDMsMTMgQEAKIAogU1lTQ1RMX0RFQ0woX3Zmc196ZnMpOwogU1lTQ1RMX05PREUoX3Zmc196ZnMs IE9JRF9BVVRPLCB6aW8sIENUTEZMQUdfUlcsIDAsICJaRlMgWklPIik7CisvKiBLRCAyMDE1LTA3 LTE1IENoYW5nZSBjbGFzcyB0byAiaW50IiBmcm9tICJzdGF0aWMgaW50IiBhcyB3ZSByZWZlcmVu Y2UgCisgKiB0aGlzIGFzIGFuIGV4dGVybiBlbHNld2hlcmUKKyAqLwogI2lmIGRlZmluZWQoX19h bWQ2NF9fKQotc3RhdGljIGludCB6aW9fdXNlX3VtYSA9IDE7CitpbnQgemlvX3VzZV91bWEgPSAx OwogI2Vsc2UKLXN0YXRpYyBpbnQgemlvX3VzZV91bWEgPSAwOworaW50IHppb191c2VfdW1hID0g MDsKICNlbmRpZgogVFVOQUJMRV9JTlQoInZmcy56ZnMuemlvLnVzZV91bWEiLCAmemlvX3VzZV91 bWEpOwogU1lTQ1RMX0lOVChfdmZzX3pmc196aW8sIE9JRF9BVVRPLCB1c2VfdW1hLCBDVExGTEFH X1JEVFVOLCAmemlvX3VzZV91bWEsIDAsCg== 159859 2015-08-14 15:36:37 +0000 2015-08-15 16:51:55 +0000 ARC Refactor / UMA Cleardown / DMU_TX dynamic against head after r286570 need_test-patch.head.r286570 text/plain 11550 junchoon SW5kZXg6IGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMv emZzL2FyYy5jCShyZXZpc2lvbiAyODU2MDIpCisrKyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xh cmlzL3V0cy9jb21tb24vZnMvemZzL2FyYy5jCSh3b3JraW5nIGNvcHkpCkBAIC0xOTAsNiArMTkw LDE1IEBAIHN0YXRpYyBpbnQgYXJjX2RlYWQ7CiBleHRlcm4gaW50IHpmc19wcmVmZXRjaF9kaXNh YmxlOwogCiAvKgorICogS0QgMjAxNS0wMi0xMAorICogV2UgaGF2ZSB0byBiZSBhYmxlIHRvIHRl c3QgZm9yIFVJTyB1c2UgaW5zaWRlIHRoZSBhcmMgYWxsb2NhdG9yLgorICogTk9URTogRE8gTk9U IE1PRElGWSBIRVJFIQorICovCitleHRlcm4gaW50IHppb191c2VfdW1hOworZXh0ZXJuIGludCB6 ZnNfZHluYW1pY193cml0ZV9idWZmZXI7CisKKworLyoKICAqIFRoZSBhcmMgaGFzIGZpbGxlZCBh dmFpbGFibGUgbWVtb3J5IGFuZCBoYXMgbm93IHdhcm1lZCB1cC4KICAqLwogc3RhdGljIGJvb2xl YW5fdCBhcmNfd2FybTsKQEAgLTIxMiw3ICsyMjEsNyBAQCBzdGF0aWMgdm9pZAogYXJjX2ZyZWVf dGFyZ2V0X2luaXQodm9pZCAqdW51c2VkIF9fdW51c2VkKQogewogCi0JemZzX2FyY19mcmVlX3Rh cmdldCA9IHZtX3BhZ2VvdXRfd2FrZXVwX3RocmVzaDsKKwl6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0g dm1fcGFnZW91dF93YWtldXBfdGhyZXNoICsgKCh2bV9jbnQudl9mcmVlX3RhcmdldCAtIHZtX3Bh Z2VvdXRfd2FrZXVwX3RocmVzaCkgLyAyKTsKIH0KIFNZU0lOSVQoYXJjX2ZyZWVfdGFyZ2V0X2lu aXQsIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX0FOWSwKICAgICBhcmNfZnJlZV90YXJn ZXRfaW5pdCwgTlVMTCk7CkBAIC0yMzMsNyArMjQyLDkgQEAgU1lTQ1RMX1VRVUFEKF92ZnNfemZz LCBPSURfQVVUTywgYXJjX2F2ZXJhZ2VfYmxvY2sKIFNZU0NUTF9JTlQoX3Zmc196ZnMsIE9JRF9B VVRPLCBhcmNfc2hyaW5rX3NoaWZ0LCBDVExGTEFHX1JXLAogICAgICZhcmNfc2hyaW5rX3NoaWZ0 LCAwLAogICAgICJsb2cyKGZyYWN0aW9uIG9mIGFyYyB0byByZWNsYWltKSIpOwotCitTWVNDVExf SU5UKF92ZnNfemZzLCBPSURfQVVUTywgZHluYW1pY193cml0ZV9idWZmZXIsIENUTEZMQUdfUldU VU4sCisgICAgJnpmc19keW5hbWljX3dyaXRlX2J1ZmZlciwgMCwKKyAgICAiRHluYW1pY2FsbHkg cmVzdHJpY3QgZGlydHkgZGF0YSB3aGVuIG1lbW9yeSBpcyBsb3ciKTsKIC8qCiAgKiBXZSBkb24n dCBoYXZlIGEgdHVuYWJsZSBmb3IgYXJjX2ZyZWVfdGFyZ2V0IGR1ZSB0byB0aGUgZGVwZW5kZW5j eSBvbgogICogcGFnZWRhZW1vbiBpbml0aWFsaXNhdGlvbi4KQEAgLTI2NDUsNiArMjY1NiwyOSBA QCBleHRlcm4ga21lbV9jYWNoZV90CSp6aW9fYnVmX2NhY2hlW107CiBleHRlcm4ga21lbV9jYWNo ZV90CSp6aW9fZGF0YV9idWZfY2FjaGVbXTsKIGV4dGVybiBrbWVtX2NhY2hlX3QJKnJhbmdlX3Nl Z19jYWNoZTsKIAorc3RhdGljIHZvaWQgX191c2VkCityZWFwX2FyY19jYWNoZXMoKQoreworCXNp emVfdCAgICAgICAgICBpOworCWttZW1fY2FjaGVfdCAgICAgICAgICAgICpwcmV2X2NhY2hlID0g TlVMTDsKKwlrbWVtX2NhY2hlX3QgICAgICAgICAgICAqcHJldl9kYXRhX2NhY2hlID0gTlVMTDsK KworCWZvciAoaSA9IDA7IGkgPCBTUEFfTUFYQkxPQ0tTSVpFID4+IFNQQV9NSU5CTE9DS1NISUZU OyBpKyspIHsKKwkJaWYgKHppb19idWZfY2FjaGVbaV0gIT0gcHJldl9jYWNoZSkgeworCQkJcHJl dl9jYWNoZSA9IHppb19idWZfY2FjaGVbaV07CisJCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19i dWZfY2FjaGVbaV0pOworCQl9CisJCWlmICh6aW9fZGF0YV9idWZfY2FjaGVbaV0gIT0gcHJldl9k YXRhX2NhY2hlKSB7CisJCQlwcmV2X2RhdGFfY2FjaGUgPSB6aW9fZGF0YV9idWZfY2FjaGVbaV07 CisJCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19kYXRhX2J1Zl9jYWNoZVtpXSk7CisJCX0KKwl9 CisJa21lbV9jYWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOworCWttZW1fY2FjaGVfcmVhcF9ub3co aGRyX2Z1bGxfY2FjaGUpOworCWttZW1fY2FjaGVfcmVhcF9ub3coaGRyX2wyb25seV9jYWNoZSk7 CisJa21lbV9jYWNoZV9yZWFwX25vdyhyYW5nZV9zZWdfY2FjaGUpOworfQorCiBzdGF0aWMgX19u b2lubGluZSB2b2lkCiBhcmNfa21lbV9yZWFwX25vdyh2b2lkKQogewpAQCAtMjY3NiwyMCArMjcw OSw3IEBAIGFyY19rbWVtX3JlYXBfbm93KHZvaWQpCiAjZW5kaWYKICNlbmRpZgogCi0JZm9yIChp ID0gMDsgaSA8IFNQQV9NQVhCTE9DS1NJWkUgPj4gU1BBX01JTkJMT0NLU0hJRlQ7IGkrKykgewot CQlpZiAoemlvX2J1Zl9jYWNoZVtpXSAhPSBwcmV2X2NhY2hlKSB7Ci0JCQlwcmV2X2NhY2hlID0g emlvX2J1Zl9jYWNoZVtpXTsKLQkJCWttZW1fY2FjaGVfcmVhcF9ub3coemlvX2J1Zl9jYWNoZVtp XSk7Ci0JCX0KLQkJaWYgKHppb19kYXRhX2J1Zl9jYWNoZVtpXSAhPSBwcmV2X2RhdGFfY2FjaGUp IHsKLQkJCXByZXZfZGF0YV9jYWNoZSA9IHppb19kYXRhX2J1Zl9jYWNoZVtpXTsKLQkJCWttZW1f Y2FjaGVfcmVhcF9ub3coemlvX2RhdGFfYnVmX2NhY2hlW2ldKTsKLQkJfQotCX0KLQlrbWVtX2Nh Y2hlX3JlYXBfbm93KGJ1Zl9jYWNoZSk7Ci0Ja21lbV9jYWNoZV9yZWFwX25vdyhoZHJfZnVsbF9j YWNoZSk7Ci0Ja21lbV9jYWNoZV9yZWFwX25vdyhoZHJfbDJvbmx5X2NhY2hlKTsKLQlrbWVtX2Nh Y2hlX3JlYXBfbm93KHJhbmdlX3NlZ19jYWNoZSk7CisJcmVhcF9hcmNfY2FjaGVzKCk7CiAKICNp ZmRlZiBpbGx1bW9zCiAJaWYgKHppb19hcmVuYSAhPSBOVUxMKSB7CkBAIC0yNzA3LDEyICsyNzI4 LDMwIEBAIGFyY19yZWNsYWltX3RocmVhZCh2b2lkICpkdW1teSBfX3VudXNlZCkKIHsKIAljbG9j a190CQkJZ3Jvd3RpbWUgPSAwOwogCWNhbGxiX2Nwcl90CQljcHI7CisJaW50CQkJYXV0b3JlYXAg PSAwOwogCiAJQ0FMTEJfQ1BSX0lOSVQoJmNwciwgJmFyY19yZWNsYWltX3Rocl9sb2NrLCBjYWxs Yl9nZW5lcmljX2NwciwgRlRBRyk7CiAKIAltdXRleF9lbnRlcigmYXJjX3JlY2xhaW1fdGhyX2xv Y2spOwogCXdoaWxlIChhcmNfdGhyZWFkX2V4aXQgPT0gMCkgeworCisjaWZkZWYgX0tFUk5FTAor LyogS0QgMjAxNS0wMi0xMAorICogUHJvdGVjdCBhZ2FpbnN0IFVNQSBmcmVlIG1lbW9yeSBibG9h dC4gIFdlIGFscmVhZHkgZG8gdGhpcyBvbiBhIGxvdy1tZW1vcnkKKyAqIGJhc2lzIGluIHRoZSBh bGxvY2F0b3I7IGl0IGhhcyB0byBoYXBwZW4gdGhlcmUgcmF0aGVyIHRoYW4gaGVyZSBkdWUgdG8K KyAqIHJlc3BvbnNlIHRpbWUgY29uc2lkZXJhdGlvbnMuICBNYWtlIHRoZSBjYWxsIGhlcmUgb25j ZSBldmVyeSAxMCBwYXNzZXMgYXMKKyAqIHdlbGw7IHRoaXMgcmVjbGFpbXMgdW51c2VkIFVNQSBi dWZmZXJzIGV2ZXJ5IDEwIHNlY29uZHMgb24gYW4gaWRsZSBzeXN0ZW0KKyAqIGFuZCBtb3JlIGZy ZXF1ZW50bHkgaWYgdGhlIHJlY2xhaW0gdGhyZWFkIGdldHMgd29rZW4gdXAgYnkgbG93IFJBTQor ICogY29uZGl0aW9ucy4KKyAqLworCQlpZiAoKHppb191c2VfdW1hKSAmJiAoYXV0b3JlYXArKyA9 PSAxMCkpIHsKKwkJCWF1dG9yZWFwID0gMDsKKwkJCURUUkFDRV9QUk9CRShhcmNfX3JlY2xhaW1f dGltZWRfcmVhcCk7CisJCQlyZWFwX2FyY19jYWNoZXMoKTsKKwkJfQorI2VuZGlmIC8qIF9LRVJO RUwgKi8KKwogCQlpbnQ2NF90IGZyZWVfbWVtb3J5ID0gYXJjX2F2YWlsYWJsZV9tZW1vcnkoKTsK IAkJaWYgKGZyZWVfbWVtb3J5IDwgMCkgewogCiAJCQlhcmNfbm9fZ3JvdyA9IEJfVFJVRTsKQEAg LTI4OTksNiArMjkzOCwxOSBAQCBhcmNfZ2V0X2RhdGFfYnVmKGFyY19idWZfdCAqYnVmKQogCQkJ YXJjX3NwYWNlX2NvbnN1bWUoc2l6ZSwgQVJDX1NQQUNFX0RBVEEpOwogCQl9IGVsc2UgewogCQkJ QVNTRVJUKHR5cGUgPT0gQVJDX0JVRkNfREFUQSk7CisjaWZkZWYgX0tFUk5FTAorLyogS0QgMjAx NS0wMi0xMAorICogSXQgd291bGQgYmUgbmljZSBpZiB3ZSBjb3VsZCBsZWF2ZSB0aGlzIHRvIHRo ZSBhcmNfcmVjbGFpbSB0aHJlYWQuCisgKiBVbmZvcnR1bmF0ZWx5IHdlIGNhbm5vdDsgdGhlIHRl c3QgaGFzIHRvIGJlIGRvbmUgaGVyZSBhcyB3ZWxsLCBiZWNhdXNlCisgKiB1bmRlciBoZWF2eSBJ L08gZGVtYW5kIHdlIGNhbiBncmFiIGVub3VnaCBSQU0gZmFzdCBlbm91Z2ggdG8gaW5kdWNlCisg KiBuYXN0eSBvc2NpbGxhdGlvbiBwcm9ibGVtcy4gIEZvcnR1bmF0ZWx5IHdlIG9ubHkgbmVlZCB0 byBjYWxsIHRoaXMgd2hlbgorICogdGhlIHN5c3RlbSBpcyB1bmRlciByZWFzb25hYmx5LXNldmVy ZSBtZW1vcnkgc3RyZXNzLgorICovCisJCQlpZiAoemlvX3VzZV91bWEgJiYgKHB0b2Iodm1fY250 LnZfZnJlZV9jb3VudCkgKyBzaXplIDwgcHRvYih2bV9jbnQudl9mcmVlX3RhcmdldCkpKSB7CisJ CQkJRFRSQUNFX1BST0JFMyhhcmNfX2FsbG9jX2xvd21lbV9yZWFwLCBpbnQsIHZtX2NudC52X2Zy ZWVfY291bnQsIGludCwgc2l6ZSwgaW50LCB2bV9jbnQudl9mcmVlX3RhcmdldCk7CisJCQkJcmVh cF9hcmNfY2FjaGVzKCk7CisJCQl9CisjZW5kaWYgLyogX0tFUk5FTCAqLwogCQkJYnVmLT5iX2Rh dGEgPSB6aW9fZGF0YV9idWZfYWxsb2Moc2l6ZSk7CiAJCQlBUkNTVEFUX0lOQ1IoYXJjc3RhdF9k YXRhX3NpemUsIHNpemUpOwogCQkJYXRvbWljX2FkZF82NCgmYXJjX3NpemUsIHNpemUpOwpJbmRl eDogY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90eC5jCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96 ZnMvZG11X3R4LmMJKHJldmlzaW9uIDI4NTYwMikKKysrIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNv bGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZG11X3R4LmMJKHdvcmtpbmcgY29weSkKQEAgLTQyLDYg KzQyLDggQEAKIHR5cGVkZWYgdm9pZCAoKmRtdV90eF9ob2xkX2Z1bmNfdCkoZG11X3R4X3QgKnR4 LCBzdHJ1Y3QgZG5vZGUgKmRuLAogICAgIHVpbnQ2NF90IGFyZzEsIHVpbnQ2NF90IGFyZzIpOwog CitleHRlcm4JaW50CXppb191c2VfdW1hOwkvKiBOZWVkcyB0byBiZSB2aXNpYmxlOyBETyBOT1Qg TU9ESUZZISAqLworaW50CXpmc19keW5hbWljX3dyaXRlX2J1ZmZlciA9IDE7CS8qIER5bmFtaWNh bGx5IHR1bmUgd3JpdGVzICovCiAKIGRtdV90eF90ICoKIGRtdV90eF9jcmVhdGVfZGQoZHNsX2Rp cl90ICpkZCkKQEAgLTEwNTgsNyArMTA2MCw3IEBAIGRtdV90eF9kZWxheShkbXVfdHhfdCAqdHgs IHVpbnQ2NF90IGRpcnR5KQogewogCWRzbF9wb29sX3QgKmRwID0gdHgtPnR4X3Bvb2w7CiAJdWlu dDY0X3QgZGVsYXlfbWluX2J5dGVzID0KLQkgICAgemZzX2RpcnR5X2RhdGFfbWF4ICogemZzX2Rl bGF5X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOworCSAgICB6ZnNfZGlydHlfZGF0YV9tYXhfaW50 ZXJuYWwgKiB6ZnNfZGVsYXlfbWluX2RpcnR5X3BlcmNlbnQgLyAxMDA7CiAJaHJ0aW1lX3Qgd2Fr ZXVwLCBtaW5fdHhfdGltZSwgbm93OwogCiAJaWYgKGRpcnR5IDw9IGRlbGF5X21pbl9ieXRlcykK QEAgLTEwNzAsMTEgKzEwNzIsMTEgQEAgZG11X3R4X2RlbGF5KGRtdV90eF90ICp0eCwgdWludDY0 X3QgZGlydHkpCiAJICogaGF2ZSB0byBoYW5kbGUgdGhlIGNhc2Ugb2YgaXQgYmVpbmcgPj0gdGhl IG1heCwgd2hpY2ggY291bGQKIAkgKiBjYXVzZSBhIGRpdmlkZS1ieS16ZXJvIGlmIGl0J3MgPT0g dGhlIG1heC4KIAkgKi8KLQlBU1NFUlQzVShkaXJ0eSwgPCwgemZzX2RpcnR5X2RhdGFfbWF4KTsK KwlBU1NFUlQzVShkaXJ0eSwgPCwgemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsKTsKIAogCW5v dyA9IGdldGhydGltZSgpOwogCW1pbl90eF90aW1lID0gemZzX2RlbGF5X3NjYWxlICoKLQkgICAg KGRpcnR5IC0gZGVsYXlfbWluX2J5dGVzKSAvICh6ZnNfZGlydHlfZGF0YV9tYXggLSBkaXJ0eSk7 CisJICAgIChkaXJ0eSAtIGRlbGF5X21pbl9ieXRlcykgLyAoemZzX2RpcnR5X2RhdGFfbWF4X2lu dGVybmFsIC0gZGlydHkpOwogCWlmIChub3cgPiB0eC0+dHhfc3RhcnQgKyBtaW5fdHhfdGltZSkK IAkJcmV0dXJuOwogCkBAIC0xMjc5LDYgKzEyODEsNyBAQCBpbnQKIGRtdV90eF9hc3NpZ24oZG11 X3R4X3QgKnR4LCB0eGdfaG93X3QgdHhnX2hvdykKIHsKIAlpbnQgZXJyOworCXN0YXRpYwl1aW50 NjRfdAlsYXN0X21heDsKIAogCUFTU0VSVCh0eC0+dHhfdHhnID09IDApOwogCUFTU0VSVCh0eGdf aG93ID09IFRYR19XQUlUIHx8IHR4Z19ob3cgPT0gVFhHX05PV0FJVCB8fApAQCAtMTI5MSw2ICsx Mjk0LDQyIEBAIGRtdV90eF9hc3NpZ24oZG11X3R4X3QgKnR4LCB0eGdfaG93X3QgdHhnX2hvdykK IAlpZiAodHhnX2hvdyA9PSBUWEdfV0FJVEVEKQogCQl0eC0+dHhfd2FpdGVkID0gQl9UUlVFOwog CisjaWZkZWYgX0tFUk5FTAorCS8qCisJICogS0QgMjAxNC0wOS0yMgorCSAqIElmIFVNQSBpcyBl bmFibGVkIGl0IGNhbiBvbmx5IHJldHVybiBhIHByZXZpb3VzbHktdXNlZCBibG9jaworCSAqIG9m IGlkZW50aWNhbCBzaXplIHRvIHdoYXQgaXQgaGFkIG91dCBiZWZvcmUuICBJZiBpdCdzIG5vdCB0 aGUKKwkgKiBzYW1lIHNpemUgaXQgd2lsbCBhbGxvY2F0ZSBhIG5ldyBvbmUuICBUaGlzIGlzIGEg cHJvYmxlbSBiZWNhdXNlCisJICogZGlydHlfZGF0YV9tYXggaXMgdGhlIHRvdGFsIGRpcnR5IHdy aXRlIGRhdGEgYWxsb3dlZCBvdXQgYXQgYW55CisJICogZ2l2ZW4gdGltZSwgYnV0IHdpdGggVU1B IG9uIHRoYXQgY2FuIG11bHRpcGx5IGJ5IHRoZSBudW1iZXIgb2YKKwkgKiBkaWZmZXJlbnQgYmxv Y2sgc2l6ZXMgKCEhKSByZXF1ZXN0ZWQgaW4gdGVybXMgb2YgZnJlZSBSQU0gdGhhdAorCSAqIGlz IGxlZnQgYWxsb2NhdGVkIGJ1dCB1bnVzZWQuICBGb3IgdGhpcyByZWFzb24gbmV2ZXIgYWxsb3cK KwkgKiBkaXJ0eV9kYXRhX21heCB0byBleGNlZWQgdGhlIGRpZmZlcmVuY2UgYmV0d2VlbiB0aGUg cGFnaW5nCisJICogdGhyZXNob2xkIGFuZCB0aGUgY3VycmVudCBmcmVlIG1lbW9yeSwgd2l0aCBh IG1pbmltdW0gb2YgMjU2TUIuCisJICogVGhpcyB0aHJvdHRsZXMgImJ1cnN0IiBhbGxvY2F0aW9u cyBhbmQgcHJldmVudHMgdGhlIHN5c3RlbSBmcm9tCisJICogY2hva2luZyBkdXJpbmcgdGltZXMg b2YgaGlnaCB3cml0ZSBJL08gZGVtYW5kLgorCSAqCisJICogV2UgYWxsb3cgdGhpcyB0byBiZSB0 dXJuZWQgb2ZmIGlmIHlvdSB3YW50IHdpdGgKKwkgKiAidmZzLnpmc19keW5hbWljX3dyaXRlX2J1 ZmZlcj0wIiwgd2hpY2ggY2FuIGJlIGRvbmUgaW4gcmVhbCB0aW1lLgorCSAqCisJICogTm90ZSB0 aGF0IHdlIHdvcmsgb24gdGhlIHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCB2YXJpYWJsZSwK KwkgKiBiZWNhdXNlIHRoZSB1c2VyIG1heSBzZXQgemZzX2RpcnR5X2RhdGFfbWF4IGhpbXNlbGYg YW5kIHdlIG11c3QKKwkgKiBtdXN0IGhvbm9yIHRoYXQgYXMgYSBoYXJkIGNhcCBzbyBpdCByZW1h aW5zIGEgdXNhYmxlIHR1bmFibGUgdmFsdWUuCisJICovCisJaWYgKHppb191c2VfdW1hICYgemZz X2R5bmFtaWNfd3JpdGVfYnVmZmVyKSB7CisJCXpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCA9 IDEgPDwgMjg7CisJCXpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCA9IE1BWCh6ZnNfZGlydHlf ZGF0YV9tYXhfaW50ZXJuYWwsIHB0b2Iodm1fY250LnZfZnJlZV9jb3VudCAtIHZtX2NudC52X2Zy ZWVfdGFyZ2V0KSk7CisJCXpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCA9IE1JTih6ZnNfZGly dHlfZGF0YV9tYXhfaW50ZXJuYWwsIHpmc19kaXJ0eV9kYXRhX21heCk7CisJCXpmc19kaXJ0eV9k YXRhX21heF9pbnRlcm5hbCA9IE1JTih6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwsIHpmc19k aXJ0eV9kYXRhX21heF9tYXgpOworCQlpZiAobGFzdF9tYXggIT0gKHpmc19kaXJ0eV9kYXRhX21h eF9pbnRlcm5hbCAvICgxMDI0ICogMTAyNCkpKSB7CisJCQlsYXN0X21heCA9IHpmc19kaXJ0eV9k YXRhX21heF9pbnRlcm5hbCAvICgxMDI0ICogMTAyNCk7CisJCQlEVFJBQ0VfUFJPQkUxKGRtdV9f dHhfZGlydHksIHVpbnQ2NF90LCBsYXN0X21heCk7CisJCX0KKwl9IGVsc2UgeworCQl6ZnNfZGly dHlfZGF0YV9tYXhfaW50ZXJuYWwgPSB6ZnNfZGlydHlfZGF0YV9tYXg7CisJfQorI2VuZGlmIC8q IF9LRVJORUwgKi8KKwogCXdoaWxlICgoZXJyID0gZG11X3R4X3RyeV9hc3NpZ24odHgsIHR4Z19o b3cpKSAhPSAwKSB7CiAJCWRtdV90eF91bmFzc2lnbih0eCk7CiAKQEAgLTEzMjEsNyArMTM2MCw3 IEBAIGRtdV90eF93YWl0KGRtdV90eF90ICp0eCkKIAkJICogc3BhY2UuCiAJCSAqLwogCQltdXRl eF9lbnRlcigmZHAtPmRwX2xvY2spOwotCQl3aGlsZSAoZHAtPmRwX2RpcnR5X3RvdGFsID49IHpm c19kaXJ0eV9kYXRhX21heCkKKwkJd2hpbGUgKGRwLT5kcF9kaXJ0eV90b3RhbCA+PSB6ZnNfZGly dHlfZGF0YV9tYXhfaW50ZXJuYWwpCiAJCQljdl93YWl0KCZkcC0+ZHBfc3BhY2VhdmFpbF9jdiwg JmRwLT5kcF9sb2NrKTsKIAkJdWludDY0X3QgZGlydHkgPSBkcC0+ZHBfZGlydHlfdG90YWw7CiAJ CW11dGV4X2V4aXQoJmRwLT5kcF9sb2NrKTsKSW5kZXg6IGNkZGwvY29udHJpYi9vcGVuc29sYXJp cy91dHMvY29tbW9uL2ZzL3pmcy9kc2xfcG9vbC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9jZGRsL2Nv bnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZHNsX3Bvb2wuYwkocmV2aXNpb24g Mjg1NjAyKQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pm cy9kc2xfcG9vbC5jCSh3b3JraW5nIGNvcHkpCkBAIC05Nyw4ICs5NywxMSBAQAogLyoKICAqIHpm c19kaXJ0eV9kYXRhX21heCB3aWxsIGJlIHNldCB0byB6ZnNfZGlydHlfZGF0YV9tYXhfcGVyY2Vu dCUgb2YgYWxsIG1lbW9yeSwKICAqIGNhcHBlZCBhdCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4LiAg SXQgY2FuIGFsc28gYmUgb3ZlcnJpZGRlbiBpbiAvZXRjL3N5c3RlbS4KKyAqIFdlIGFsc28gZHlu YW1pY2FsbHkgdHVuZSBkdXJpbmcgbG93IG1lbW9yeSwgaG9ub3JpbmcgdGhlIHN5c2N0bCBzZXQs IHNvCisgKiBpbnRlcm5hbCBjb21wYXJpc29ucyBhcmUgYWdhaW5zdCB6ZnNfZGlydHlfZGF0YV9t YXhfaW50ZXJuYWwuCiAgKi8KIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heDsKK3VpbnQ2NF90 IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbDsKIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21h eF9tYXggPSA0VUxMICogMTAyNCAqIDEwMjQgKiAxMDI0OwogaW50IHpmc19kaXJ0eV9kYXRhX21h eF9wZXJjZW50ID0gMTA7CiAKQEAgLTU0Nyw3ICs1NTAsNyBAQCBkc2xfcG9vbF9kaXJ0eV9kZWx0 YShkc2xfcG9vbF90ICpkcCwgaW50NjRfdCBkZWx0YQogCSAqIE5vdGU6IHdlIHNpZ25hbCBldmVu IHdoZW4gaW5jcmVhc2luZyBkcF9kaXJ0eV90b3RhbC4KIAkgKiBUaGlzIGVuc3VyZXMgZm9yd2Fy ZCBwcm9ncmVzcyAtLSBlYWNoIHRocmVhZCB3YWtlcyB0aGUgbmV4dCB3YWl0ZXIuCiAJICovCi0J aWYgKGRwLT5kcF9kaXJ0eV90b3RhbCA8PSB6ZnNfZGlydHlfZGF0YV9tYXgpCisJaWYgKGRwLT5k cF9kaXJ0eV90b3RhbCA8PSB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwpCiAJCWN2X3NpZ25h bCgmZHAtPmRwX3NwYWNlYXZhaWxfY3YpOwogfQogCkBAIC03MjYsNyArNzI5LDcgQEAgYm9vbGVh bl90CiBkc2xfcG9vbF9uZWVkX2RpcnR5X2RlbGF5KGRzbF9wb29sX3QgKmRwKQogewogCXVpbnQ2 NF90IGRlbGF5X21pbl9ieXRlcyA9Ci0JICAgIHpmc19kaXJ0eV9kYXRhX21heCAqIHpmc19kZWxh eV9taW5fZGlydHlfcGVyY2VudCAvIDEwMDsKKwkgICAgemZzX2RpcnR5X2RhdGFfbWF4X2ludGVy bmFsICogemZzX2RlbGF5X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOwogCWJvb2xlYW5fdCBydjsK IAogCW11dGV4X2VudGVyKCZkcC0+ZHBfbG9jayk7CkluZGV4OiBjZGRsL2NvbnRyaWIvb3BlbnNv bGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvc3lzL2RzbF9wb29sLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lz L2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9zeXMvZHNsX3Bvb2wu aAkocmV2aXNpb24gMjg1NjAyKQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMv Y29tbW9uL2ZzL3pmcy9zeXMvZHNsX3Bvb2wuaAkod29ya2luZyBjb3B5KQpAQCAtNTAsNiArNTAs NyBAQCBzdHJ1Y3QgZG11X3R4Owogc3RydWN0IGRzbF9zY2FuOwogCiBleHRlcm4gdWludDY0X3Qg emZzX2RpcnR5X2RhdGFfbWF4OworZXh0ZXJuIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heF9p bnRlcm5hbDsKIGV4dGVybiB1aW50NjRfdCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4OwogZXh0ZXJu IHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX3N5bmM7CiBleHRlcm4gaW50IHpmc19kaXJ0eV9kYXRh X21heF9wZXJjZW50OwpJbmRleDogY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24v ZnMvemZzL3ppby5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMv dXRzL2NvbW1vbi9mcy96ZnMvemlvLmMJKHJldmlzaW9uIDI4NTYwMikKKysrIHN5cy9jZGRsL2Nv bnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvemlvLmMJKHdvcmtpbmcgY29weSkK QEAgLTQzLDEwICs0MywxMyBAQAogCiBTWVNDVExfREVDTChfdmZzX3pmcyk7CiBTWVNDVExfTk9E RShfdmZzX3pmcywgT0lEX0FVVE8sIHppbywgQ1RMRkxBR19SVywgMCwgIlpGUyBaSU8iKTsKKy8q IEtEIDIwMTUtMDctMTUgQ2hhbmdlIGNsYXNzIHRvICJpbnQiIGZyb20gInN0YXRpYyBpbnQiIGFz IHdlIHJlZmVyZW5jZSAKKyAqIHRoaXMgYXMgYW4gZXh0ZXJuIGVsc2V3aGVyZQorICovCiAjaWYg ZGVmaW5lZChfX2FtZDY0X18pCi1zdGF0aWMgaW50IHppb191c2VfdW1hID0gMTsKK2ludCB6aW9f dXNlX3VtYSA9IDE7CiAjZWxzZQotc3RhdGljIGludCB6aW9fdXNlX3VtYSA9IDA7CitpbnQgemlv X3VzZV91bWEgPSAwOwogI2VuZGlmCiBUVU5BQkxFX0lOVCgidmZzLnpmcy56aW8udXNlX3VtYSIs ICZ6aW9fdXNlX3VtYSk7CiBTWVNDVExfSU5UKF92ZnNfemZzX3ppbywgT0lEX0FVVE8sIHVzZV91 bWEsIENUTEZMQUdfUkRUVU4sICZ6aW9fdXNlX3VtYSwgMCwK 159905 2015-08-15 16:51:55 +0000 2015-08-15 16:51:55 +0000 ARC Refactor / UMA Cleardown / DMU_TX dynamic against head after r286776 need_test-patch.head.r286776 text/plain 11030 junchoon SW5kZXg6IHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvYXJj LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9u L2ZzL3pmcy9hcmMuYwkocmV2aXNpb24gMjg2Nzk1KQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVu c29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMjE2LDYg KzIxNiwxNSBAQAogZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hfZGlzYWJsZTsKIAogLyoKKyAqIEtE IDIwMTUtMDItMTAKKyAqIFdlIGhhdmUgdG8gYmUgYWJsZSB0byB0ZXN0IGZvciBVSU8gdXNlIGlu c2lkZSB0aGUgYXJjIGFsbG9jYXRvci4KKyAqIE5PVEU6IERPIE5PVCBNT0RJRlkgSEVSRSEKKyAq LworZXh0ZXJuIGludCB6aW9fdXNlX3VtYTsKK2V4dGVybiBpbnQgemZzX2R5bmFtaWNfd3JpdGVf YnVmZmVyOworCisKKy8qCiAgKiBUaGUgYXJjIGhhcyBmaWxsZWQgYXZhaWxhYmxlIG1lbW9yeSBh bmQgaGFzIG5vdyB3YXJtZWQgdXAuCiAgKi8KIHN0YXRpYyBib29sZWFuX3QgYXJjX3dhcm07CkBA IC0yNDIsNyArMjUxLDcgQEAKIGFyY19mcmVlX3RhcmdldF9pbml0KHZvaWQgKnVudXNlZCBfX3Vu dXNlZCkKIHsKIAotCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2bV9wYWdlb3V0X3dha2V1cF90aHJl c2g7CisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2VvdXRfd2FrZXVwX3RocmVzaCArICgo dm1fY250LnZfZnJlZV90YXJnZXQgLSB2bV9wYWdlb3V0X3dha2V1cF90aHJlc2gpIC8gMik7CiB9 CiBTWVNJTklUKGFyY19mcmVlX3RhcmdldF9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9P UkRFUl9BTlksCiAgICAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIE5VTEwpOwpAQCAtMjYxLDcgKzI3 MCw5IEBACiBTWVNDVExfSU5UKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX3Nocmlua19zaGlmdCwg Q1RMRkxBR19SVywKICAgICAmYXJjX3Nocmlua19zaGlmdCwgMCwKICAgICAibG9nMihmcmFjdGlv biBvZiBhcmMgdG8gcmVjbGFpbSkiKTsKLQorU1lTQ1RMX0lOVChfdmZzX3pmcywgT0lEX0FVVE8s IGR5bmFtaWNfd3JpdGVfYnVmZmVyLCBDVExGTEFHX1JXVFVOLAorICAgICZ6ZnNfZHluYW1pY193 cml0ZV9idWZmZXIsIDAsCisgICAgIkR5bmFtaWNhbGx5IHJlc3RyaWN0IGRpcnR5IGRhdGEgd2hl biBtZW1vcnkgaXMgbG93Iik7CiAvKgogICogV2UgZG9uJ3QgaGF2ZSBhIHR1bmFibGUgZm9yIGFy Y19mcmVlX3RhcmdldCBkdWUgdG8gdGhlIGRlcGVuZGVuY3kgb24KICAqIHBhZ2VkYWVtb24gaW5p dGlhbGlzYXRpb24uCkBAIC0zNTE4LDYgKzM1MjksMjkgQEAKIGV4dGVybiBrbWVtX2NhY2hlX3QJ Knppb19kYXRhX2J1Zl9jYWNoZVtdOwogZXh0ZXJuIGttZW1fY2FjaGVfdAkqcmFuZ2Vfc2VnX2Nh Y2hlOwogCitzdGF0aWMgdm9pZCBfX3VzZWQKK3JlYXBfYXJjX2NhY2hlcygpCit7CisJc2l6ZV90 ICAgICAgICAgIGk7CisJa21lbV9jYWNoZV90ICAgICAgICAgICAgKnByZXZfY2FjaGUgPSBOVUxM OworCWttZW1fY2FjaGVfdCAgICAgICAgICAgICpwcmV2X2RhdGFfY2FjaGUgPSBOVUxMOworCisJ Zm9yIChpID0gMDsgaSA8IFNQQV9NQVhCTE9DS1NJWkUgPj4gU1BBX01JTkJMT0NLU0hJRlQ7IGkr KykgeworCQlpZiAoemlvX2J1Zl9jYWNoZVtpXSAhPSBwcmV2X2NhY2hlKSB7CisJCQlwcmV2X2Nh Y2hlID0gemlvX2J1Zl9jYWNoZVtpXTsKKwkJCWttZW1fY2FjaGVfcmVhcF9ub3coemlvX2J1Zl9j YWNoZVtpXSk7CisJCX0KKwkJaWYgKHppb19kYXRhX2J1Zl9jYWNoZVtpXSAhPSBwcmV2X2RhdGFf Y2FjaGUpIHsKKwkJCXByZXZfZGF0YV9jYWNoZSA9IHppb19kYXRhX2J1Zl9jYWNoZVtpXTsKKwkJ CWttZW1fY2FjaGVfcmVhcF9ub3coemlvX2RhdGFfYnVmX2NhY2hlW2ldKTsKKwkJfQorCX0KKwlr bWVtX2NhY2hlX3JlYXBfbm93KGJ1Zl9jYWNoZSk7CisJa21lbV9jYWNoZV9yZWFwX25vdyhoZHJf ZnVsbF9jYWNoZSk7CisJa21lbV9jYWNoZV9yZWFwX25vdyhoZHJfbDJvbmx5X2NhY2hlKTsKKwlr bWVtX2NhY2hlX3JlYXBfbm93KHJhbmdlX3NlZ19jYWNoZSk7Cit9CisKIHN0YXRpYyBfX25vaW5s aW5lIHZvaWQKIGFyY19rbWVtX3JlYXBfbm93KHZvaWQpCiB7CkBAIC0zNTQyLDIwICszNTc2LDcg QEAKICNlbmRpZgogI2VuZGlmCiAKLQlmb3IgKGkgPSAwOyBpIDwgU1BBX01BWEJMT0NLU0laRSA+ PiBTUEFfTUlOQkxPQ0tTSElGVDsgaSsrKSB7Ci0JCWlmICh6aW9fYnVmX2NhY2hlW2ldICE9IHBy ZXZfY2FjaGUpIHsKLQkJCXByZXZfY2FjaGUgPSB6aW9fYnVmX2NhY2hlW2ldOwotCQkJa21lbV9j YWNoZV9yZWFwX25vdyh6aW9fYnVmX2NhY2hlW2ldKTsKLQkJfQotCQlpZiAoemlvX2RhdGFfYnVm X2NhY2hlW2ldICE9IHByZXZfZGF0YV9jYWNoZSkgewotCQkJcHJldl9kYXRhX2NhY2hlID0gemlv X2RhdGFfYnVmX2NhY2hlW2ldOwotCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6aW9fZGF0YV9idWZf Y2FjaGVbaV0pOwotCQl9Ci0JfQotCWttZW1fY2FjaGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKLQlr bWVtX2NhY2hlX3JlYXBfbm93KGhkcl9mdWxsX2NhY2hlKTsKLQlrbWVtX2NhY2hlX3JlYXBfbm93 KGhkcl9sMm9ubHlfY2FjaGUpOwotCWttZW1fY2FjaGVfcmVhcF9ub3cocmFuZ2Vfc2VnX2NhY2hl KTsKKwlyZWFwX2FyY19jYWNoZXMoKTsKIAogI2lmZGVmIGlsbHVtb3MKIAlpZiAoemlvX2FyZW5h ICE9IE5VTEwpIHsKQEAgLTM1OTAsMTEgKzM2MTEsMjkgQEAKIHsKIAljbG9ja190CQkJZ3Jvd3Rp bWUgPSAwOwogCWNhbGxiX2Nwcl90CQljcHI7CisJaW50CQkJYXV0b3JlYXAgPSAwOwogCiAJQ0FM TEJfQ1BSX0lOSVQoJmNwciwgJmFyY19yZWNsYWltX2xvY2ssIGNhbGxiX2dlbmVyaWNfY3ByLCBG VEFHKTsKIAogCW11dGV4X2VudGVyKCZhcmNfcmVjbGFpbV9sb2NrKTsKIAl3aGlsZSAoIWFyY19y ZWNsYWltX3RocmVhZF9leGl0KSB7CisKKyNpZmRlZiBfS0VSTkVMCisvKiBLRCAyMDE1LTAyLTEw CisgKiBQcm90ZWN0IGFnYWluc3QgVU1BIGZyZWUgbWVtb3J5IGJsb2F0LiAgV2UgYWxyZWFkeSBk byB0aGlzIG9uIGEgbG93LW1lbW9yeQorICogYmFzaXMgaW4gdGhlIGFsbG9jYXRvcjsgaXQgaGFz IHRvIGhhcHBlbiB0aGVyZSByYXRoZXIgdGhhbiBoZXJlIGR1ZSB0bworICogcmVzcG9uc2UgdGlt ZSBjb25zaWRlcmF0aW9ucy4gIE1ha2UgdGhlIGNhbGwgaGVyZSBvbmNlIGV2ZXJ5IDEwIHBhc3Nl cyBhcworICogd2VsbDsgdGhpcyByZWNsYWltcyB1bnVzZWQgVU1BIGJ1ZmZlcnMgZXZlcnkgMTAg c2Vjb25kcyBvbiBhbiBpZGxlIHN5c3RlbQorICogYW5kIG1vcmUgZnJlcXVlbnRseSBpZiB0aGUg cmVjbGFpbSB0aHJlYWQgZ2V0cyB3b2tlbiB1cCBieSBsb3cgUkFNCisgKiBjb25kaXRpb25zLgor ICovCisJCWlmICgoemlvX3VzZV91bWEpICYmIChhdXRvcmVhcCsrID09IDEwKSkgeworCQkJYXV0 b3JlYXAgPSAwOworCQkJRFRSQUNFX1BST0JFKGFyY19fcmVjbGFpbV90aW1lZF9yZWFwKTsKKwkJ CXJlYXBfYXJjX2NhY2hlcygpOworCQl9CisjZW5kaWYgLyogX0tFUk5FTCAqLworCiAJCWludDY0 X3QgZnJlZV9tZW1vcnkgPSBhcmNfYXZhaWxhYmxlX21lbW9yeSgpOwogCQl1aW50NjRfdCBldmlj dGVkID0gMDsKIApAQCAtMzg2MCw2ICszODk5LDE5IEBACiAJCWFyY19zcGFjZV9jb25zdW1lKHNp emUsIEFSQ19TUEFDRV9NRVRBKTsKIAl9IGVsc2UgewogCQlBU1NFUlQodHlwZSA9PSBBUkNfQlVG Q19EQVRBKTsKKyNpZmRlZiBfS0VSTkVMCisvKiBLRCAyMDE1LTAyLTEwCisgKiBJdCB3b3VsZCBi ZSBuaWNlIGlmIHdlIGNvdWxkIGxlYXZlIHRoaXMgdG8gdGhlIGFyY19yZWNsYWltIHRocmVhZC4K KyAqIFVuZm9ydHVuYXRlbHkgd2UgY2Fubm90OyB0aGUgdGVzdCBoYXMgdG8gYmUgZG9uZSBoZXJl IGFzIHdlbGwsIGJlY2F1c2UKKyAqIHVuZGVyIGhlYXZ5IEkvTyBkZW1hbmQgd2UgY2FuIGdyYWIg ZW5vdWdoIFJBTSBmYXN0IGVub3VnaCB0byBpbmR1Y2UKKyAqIG5hc3R5IG9zY2lsbGF0aW9uIHBy b2JsZW1zLiAgRm9ydHVuYXRlbHkgd2Ugb25seSBuZWVkIHRvIGNhbGwgdGhpcyB3aGVuCisgKiB0 aGUgc3lzdGVtIGlzIHVuZGVyIHJlYXNvbmFibHktc2V2ZXJlIG1lbW9yeSBzdHJlc3MuCisgKi8K KwkJaWYgKHppb191c2VfdW1hICYmIChwdG9iKHZtX2NudC52X2ZyZWVfY291bnQpICsgc2l6ZSA8 IHB0b2Iodm1fY250LnZfZnJlZV90YXJnZXQpKSkgeworCQkJRFRSQUNFX1BST0JFMyhhcmNfX2Fs bG9jX2xvd21lbV9yZWFwLCBpbnQsIHZtX2NudC52X2ZyZWVfY291bnQsIGludCwgc2l6ZSwgaW50 LCB2bV9jbnQudl9mcmVlX3RhcmdldCk7CisJCQlyZWFwX2FyY19jYWNoZXMoKTsKKwkJfQorI2Vu ZGlmIC8qIF9LRVJORUwgKi8KIAkJYnVmLT5iX2RhdGEgPSB6aW9fZGF0YV9idWZfYWxsb2Moc2l6 ZSk7CiAJCWFyY19zcGFjZV9jb25zdW1lKHNpemUsIEFSQ19TUEFDRV9EQVRBKTsKIAl9CkluZGV4 OiBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90eC5j Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9m cy96ZnMvZG11X3R4LmMJKHJldmlzaW9uIDI4Njc5NSkKKysrIHN5cy9jZGRsL2NvbnRyaWIvb3Bl bnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZG11X3R4LmMJKHdvcmtpbmcgY29weSkKQEAgLTQy LDYgKzQyLDggQEAKIHR5cGVkZWYgdm9pZCAoKmRtdV90eF9ob2xkX2Z1bmNfdCkoZG11X3R4X3Qg KnR4LCBzdHJ1Y3QgZG5vZGUgKmRuLAogICAgIHVpbnQ2NF90IGFyZzEsIHVpbnQ2NF90IGFyZzIp OwogCitleHRlcm4JaW50CXppb191c2VfdW1hOwkvKiBOZWVkcyB0byBiZSB2aXNpYmxlOyBETyBO T1QgTU9ESUZZISAqLworaW50CXpmc19keW5hbWljX3dyaXRlX2J1ZmZlciA9IDE7CS8qIER5bmFt aWNhbGx5IHR1bmUgd3JpdGVzICovCiAKIGRtdV90eF90ICoKIGRtdV90eF9jcmVhdGVfZGQoZHNs X2Rpcl90ICpkZCkKQEAgLTEwNjAsNyArMTA2Miw3IEBACiB7CiAJZHNsX3Bvb2xfdCAqZHAgPSB0 eC0+dHhfcG9vbDsKIAl1aW50NjRfdCBkZWxheV9taW5fYnl0ZXMgPQotCSAgICB6ZnNfZGlydHlf ZGF0YV9tYXggKiB6ZnNfZGVsYXlfbWluX2RpcnR5X3BlcmNlbnQgLyAxMDA7CisJICAgIHpmc19k aXJ0eV9kYXRhX21heF9pbnRlcm5hbCAqIHpmc19kZWxheV9taW5fZGlydHlfcGVyY2VudCAvIDEw MDsKIAlocnRpbWVfdCB3YWtldXAsIG1pbl90eF90aW1lLCBub3c7CiAKIAlpZiAoZGlydHkgPD0g ZGVsYXlfbWluX2J5dGVzKQpAQCAtMTA3MiwxMSArMTA3NCwxMSBAQAogCSAqIGhhdmUgdG8gaGFu ZGxlIHRoZSBjYXNlIG9mIGl0IGJlaW5nID49IHRoZSBtYXgsIHdoaWNoIGNvdWxkCiAJICogY2F1 c2UgYSBkaXZpZGUtYnktemVybyBpZiBpdCdzID09IHRoZSBtYXguCiAJICovCi0JQVNTRVJUM1Uo ZGlydHksIDwsIHpmc19kaXJ0eV9kYXRhX21heCk7CisJQVNTRVJUM1UoZGlydHksIDwsIHpmc19k aXJ0eV9kYXRhX21heF9pbnRlcm5hbCk7CiAKIAlub3cgPSBnZXRocnRpbWUoKTsKIAltaW5fdHhf dGltZSA9IHpmc19kZWxheV9zY2FsZSAqCi0JICAgIChkaXJ0eSAtIGRlbGF5X21pbl9ieXRlcykg LyAoemZzX2RpcnR5X2RhdGFfbWF4IC0gZGlydHkpOworCSAgICAoZGlydHkgLSBkZWxheV9taW5f Ynl0ZXMpIC8gKHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCAtIGRpcnR5KTsKIAlpZiAobm93 ID4gdHgtPnR4X3N0YXJ0ICsgbWluX3R4X3RpbWUpCiAJCXJldHVybjsKIApAQCAtMTI4MSw2ICsx MjgzLDcgQEAKIGRtdV90eF9hc3NpZ24oZG11X3R4X3QgKnR4LCB0eGdfaG93X3QgdHhnX2hvdykK IHsKIAlpbnQgZXJyOworCXN0YXRpYwl1aW50NjRfdAlsYXN0X21heDsKIAogCUFTU0VSVCh0eC0+ dHhfdHhnID09IDApOwogCUFTU0VSVCh0eGdfaG93ID09IFRYR19XQUlUIHx8IHR4Z19ob3cgPT0g VFhHX05PV0FJVCB8fApAQCAtMTI5Myw2ICsxMjk2LDQyIEBACiAJaWYgKHR4Z19ob3cgPT0gVFhH X1dBSVRFRCkKIAkJdHgtPnR4X3dhaXRlZCA9IEJfVFJVRTsKIAorI2lmZGVmIF9LRVJORUwKKwkv KgorCSAqIEtEIDIwMTQtMDktMjIKKwkgKiBJZiBVTUEgaXMgZW5hYmxlZCBpdCBjYW4gb25seSBy ZXR1cm4gYSBwcmV2aW91c2x5LXVzZWQgYmxvY2sKKwkgKiBvZiBpZGVudGljYWwgc2l6ZSB0byB3 aGF0IGl0IGhhZCBvdXQgYmVmb3JlLiAgSWYgaXQncyBub3QgdGhlCisJICogc2FtZSBzaXplIGl0 IHdpbGwgYWxsb2NhdGUgYSBuZXcgb25lLiAgVGhpcyBpcyBhIHByb2JsZW0gYmVjYXVzZQorCSAq IGRpcnR5X2RhdGFfbWF4IGlzIHRoZSB0b3RhbCBkaXJ0eSB3cml0ZSBkYXRhIGFsbG93ZWQgb3V0 IGF0IGFueQorCSAqIGdpdmVuIHRpbWUsIGJ1dCB3aXRoIFVNQSBvbiB0aGF0IGNhbiBtdWx0aXBs eSBieSB0aGUgbnVtYmVyIG9mCisJICogZGlmZmVyZW50IGJsb2NrIHNpemVzICghISkgcmVxdWVz dGVkIGluIHRlcm1zIG9mIGZyZWUgUkFNIHRoYXQKKwkgKiBpcyBsZWZ0IGFsbG9jYXRlZCBidXQg dW51c2VkLiAgRm9yIHRoaXMgcmVhc29uIG5ldmVyIGFsbG93CisJICogZGlydHlfZGF0YV9tYXgg dG8gZXhjZWVkIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gdGhlIHBhZ2luZworCSAqIHRocmVzaG9s ZCBhbmQgdGhlIGN1cnJlbnQgZnJlZSBtZW1vcnksIHdpdGggYSBtaW5pbXVtIG9mIDI1Nk1CLgor CSAqIFRoaXMgdGhyb3R0bGVzICJidXJzdCIgYWxsb2NhdGlvbnMgYW5kIHByZXZlbnRzIHRoZSBz eXN0ZW0gZnJvbQorCSAqIGNob2tpbmcgZHVyaW5nIHRpbWVzIG9mIGhpZ2ggd3JpdGUgSS9PIGRl bWFuZC4KKwkgKgorCSAqIFdlIGFsbG93IHRoaXMgdG8gYmUgdHVybmVkIG9mZiBpZiB5b3Ugd2Fu dCB3aXRoCisJICogInZmcy56ZnNfZHluYW1pY193cml0ZV9idWZmZXI9MCIsIHdoaWNoIGNhbiBi ZSBkb25lIGluIHJlYWwgdGltZS4KKwkgKgorCSAqIE5vdGUgdGhhdCB3ZSB3b3JrIG9uIHRoZSB6 ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgdmFyaWFibGUsCisJICogYmVjYXVzZSB0aGUgdXNl ciBtYXkgc2V0IHpmc19kaXJ0eV9kYXRhX21heCBoaW1zZWxmIGFuZCB3ZSBtdXN0CisJICogbXVz dCBob25vciB0aGF0IGFzIGEgaGFyZCBjYXAgc28gaXQgcmVtYWlucyBhIHVzYWJsZSB0dW5hYmxl IHZhbHVlLgorCSAqLworCWlmICh6aW9fdXNlX3VtYSAmIHpmc19keW5hbWljX3dyaXRlX2J1ZmZl cikgeworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSAxIDw8IDI4OworCQl6ZnNfZGly dHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBNQVgoemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsLCBw dG9iKHZtX2NudC52X2ZyZWVfY291bnQgLSB2bV9jbnQudl9mcmVlX3RhcmdldCkpOworCQl6ZnNf ZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBNSU4oemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFs LCB6ZnNfZGlydHlfZGF0YV9tYXgpOworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBN SU4oemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsLCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4KTsK KwkJaWYgKGxhc3RfbWF4ICE9ICh6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgLyAoMTAyNCAq IDEwMjQpKSkgeworCQkJbGFzdF9tYXggPSB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgLyAo MTAyNCAqIDEwMjQpOworCQkJRFRSQUNFX1BST0JFMShkbXVfX3R4X2RpcnR5LCB1aW50NjRfdCwg bGFzdF9tYXgpOworCQl9CisJfSBlbHNlIHsKKwkJemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFs ID0gemZzX2RpcnR5X2RhdGFfbWF4OworCX0KKyNlbmRpZiAvKiBfS0VSTkVMICovCisKIAl3aGls ZSAoKGVyciA9IGRtdV90eF90cnlfYXNzaWduKHR4LCB0eGdfaG93KSkgIT0gMCkgewogCQlkbXVf dHhfdW5hc3NpZ24odHgpOwogCkBAIC0xMzIzLDcgKzEzNjIsNyBAQAogCQkgKiBzcGFjZS4KIAkJ ICovCiAJCW11dGV4X2VudGVyKCZkcC0+ZHBfbG9jayk7Ci0JCXdoaWxlIChkcC0+ZHBfZGlydHlf dG90YWwgPj0gemZzX2RpcnR5X2RhdGFfbWF4KQorCQl3aGlsZSAoZHAtPmRwX2RpcnR5X3RvdGFs ID49IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCkKIAkJCWN2X3dhaXQoJmRwLT5kcF9zcGFj ZWF2YWlsX2N2LCAmZHAtPmRwX2xvY2spOwogCQl1aW50NjRfdCBkaXJ0eSA9IGRwLT5kcF9kaXJ0 eV90b3RhbDsKIAkJbXV0ZXhfZXhpdCgmZHAtPmRwX2xvY2spOwpJbmRleDogc3lzL2NkZGwvY29u dHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9kc2xfcG9vbC5jCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZHNsX3Bv b2wuYwkocmV2aXNpb24gMjg2Nzk1KQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91 dHMvY29tbW9uL2ZzL3pmcy9kc2xfcG9vbC5jCSh3b3JraW5nIGNvcHkpCkBAIC05OCw4ICs5OCwx MSBAQAogLyoKICAqIHpmc19kaXJ0eV9kYXRhX21heCB3aWxsIGJlIHNldCB0byB6ZnNfZGlydHlf ZGF0YV9tYXhfcGVyY2VudCUgb2YgYWxsIG1lbW9yeSwKICAqIGNhcHBlZCBhdCB6ZnNfZGlydHlf ZGF0YV9tYXhfbWF4LiAgSXQgY2FuIGFsc28gYmUgb3ZlcnJpZGRlbiBpbiAvZXRjL3N5c3RlbS4K KyAqIFdlIGFsc28gZHluYW1pY2FsbHkgdHVuZSBkdXJpbmcgbG93IG1lbW9yeSwgaG9ub3Jpbmcg dGhlIHN5c2N0bCBzZXQsIHNvCisgKiBpbnRlcm5hbCBjb21wYXJpc29ucyBhcmUgYWdhaW5zdCB6 ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwuCiAgKi8KIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRh X21heDsKK3VpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbDsKIHVpbnQ2NF90IHpm c19kaXJ0eV9kYXRhX21heF9tYXggPSA0VUxMICogMTAyNCAqIDEwMjQgKiAxMDI0OwogaW50IHpm c19kaXJ0eV9kYXRhX21heF9wZXJjZW50ID0gMTA7CiAKQEAgLTU1Myw3ICs1NTYsNyBAQAogCSAq IE5vdGU6IHdlIHNpZ25hbCBldmVuIHdoZW4gaW5jcmVhc2luZyBkcF9kaXJ0eV90b3RhbC4KIAkg KiBUaGlzIGVuc3VyZXMgZm9yd2FyZCBwcm9ncmVzcyAtLSBlYWNoIHRocmVhZCB3YWtlcyB0aGUg bmV4dCB3YWl0ZXIuCiAJICovCi0JaWYgKGRwLT5kcF9kaXJ0eV90b3RhbCA8PSB6ZnNfZGlydHlf ZGF0YV9tYXgpCisJaWYgKGRwLT5kcF9kaXJ0eV90b3RhbCA8PSB6ZnNfZGlydHlfZGF0YV9tYXhf aW50ZXJuYWwpCiAJCWN2X3NpZ25hbCgmZHAtPmRwX3NwYWNlYXZhaWxfY3YpOwogfQogCkBAIC03 MzIsNyArNzM1LDcgQEAKIGRzbF9wb29sX25lZWRfZGlydHlfZGVsYXkoZHNsX3Bvb2xfdCAqZHAp CiB7CiAJdWludDY0X3QgZGVsYXlfbWluX2J5dGVzID0KLQkgICAgemZzX2RpcnR5X2RhdGFfbWF4 ICogemZzX2RlbGF5X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOworCSAgICB6ZnNfZGlydHlfZGF0 YV9tYXhfaW50ZXJuYWwgKiB6ZnNfZGVsYXlfbWluX2RpcnR5X3BlcmNlbnQgLyAxMDA7CiAJYm9v bGVhbl90IHJ2OwogCiAJbXV0ZXhfZW50ZXIoJmRwLT5kcF9sb2NrKTsKSW5kZXg6IHN5cy9jZGRs L2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvc3lzL2RzbF9wb29sLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pm cy9zeXMvZHNsX3Bvb2wuaAkocmV2aXNpb24gMjg2Nzk1KQorKysgc3lzL2NkZGwvY29udHJpYi9v cGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9zeXMvZHNsX3Bvb2wuaAkod29ya2luZyBjb3B5 KQpAQCAtNTAsNiArNTAsNyBAQAogc3RydWN0IGRzbF9zY2FuOwogCiBleHRlcm4gdWludDY0X3Qg emZzX2RpcnR5X2RhdGFfbWF4OworZXh0ZXJuIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heF9p bnRlcm5hbDsKIGV4dGVybiB1aW50NjRfdCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4OwogZXh0ZXJu IHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX3N5bmM7CiBleHRlcm4gaW50IHpmc19kaXJ0eV9kYXRh X21heF9wZXJjZW50OwpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29t bW9uL2ZzL3pmcy96aW8uYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xh cmlzL3V0cy9jb21tb24vZnMvemZzL3ppby5jCShyZXZpc2lvbiAyODY3OTUpCisrKyBzeXMvY2Rk bC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3ppby5jCSh3b3JraW5nIGNv cHkpCkBAIC00MywxMCArNDMsMTMgQEAKIAogU1lTQ1RMX0RFQ0woX3Zmc196ZnMpOwogU1lTQ1RM X05PREUoX3Zmc196ZnMsIE9JRF9BVVRPLCB6aW8sIENUTEZMQUdfUlcsIDAsICJaRlMgWklPIik7 CisvKiBLRCAyMDE1LTA3LTE1IENoYW5nZSBjbGFzcyB0byAiaW50IiBmcm9tICJzdGF0aWMgaW50 IiBhcyB3ZSByZWZlcmVuY2UgCisgKiB0aGlzIGFzIGFuIGV4dGVybiBlbHNld2hlcmUKKyAqLwog I2lmIGRlZmluZWQoX19hbWQ2NF9fKQotc3RhdGljIGludCB6aW9fdXNlX3VtYSA9IDE7CitpbnQg emlvX3VzZV91bWEgPSAxOwogI2Vsc2UKLXN0YXRpYyBpbnQgemlvX3VzZV91bWEgPSAwOworaW50 IHppb191c2VfdW1hID0gMDsKICNlbmRpZgogU1lTQ1RMX0lOVChfdmZzX3pmc196aW8sIE9JRF9B VVRPLCB1c2VfdW1hLCBDVExGTEFHX1JEVFVOLCAmemlvX3VzZV91bWEsIDAsCiAgICAgIlVzZSB1 bWEoOSkgZm9yIFpJTyBhbGxvY2F0aW9ucyIpOwo= 161691 2015-10-04 11:51:18 +0000 2015-10-04 11:51:18 +0000 ARC Refactor / UMA Cleardown / DMU_TX dynamic against stable/10 after r288599 patch.stable10.r288599 text/plain 11007 junchoon SW5kZXg6IHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvYXJj LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9u L2ZzL3pmcy9hcmMuYwkocmV2aXNpb24gMjg2Nzk1KQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVu c29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMjE2LDYg KzIxNiwxNSBAQAogZXh0ZXJuIGludCB6ZnNfcHJlZmV0Y2hfZGlzYWJsZTsKIAogLyoKKyAqIEtE IDIwMTUtMDItMTAKKyAqIFdlIGhhdmUgdG8gYmUgYWJsZSB0byB0ZXN0IGZvciBVSU8gdXNlIGlu c2lkZSB0aGUgYXJjIGFsbG9jYXRvci4KKyAqIE5PVEU6IERPIE5PVCBNT0RJRlkgSEVSRSEKKyAq LworZXh0ZXJuIGludCB6aW9fdXNlX3VtYTsKK2V4dGVybiBpbnQgemZzX2R5bmFtaWNfd3JpdGVf YnVmZmVyOworCisKKy8qCiAgKiBUaGUgYXJjIGhhcyBmaWxsZWQgYXZhaWxhYmxlIG1lbW9yeSBh bmQgaGFzIG5vdyB3YXJtZWQgdXAuCiAgKi8KIHN0YXRpYyBib29sZWFuX3QgYXJjX3dhcm07CkBA IC0yNDIsNyArMjUxLDcgQEAKIGFyY19mcmVlX3RhcmdldF9pbml0KHZvaWQgKnVudXNlZCBfX3Vu dXNlZCkKIHsKIAotCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2bV9wYWdlb3V0X3dha2V1cF90aHJl c2g7CisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2VvdXRfd2FrZXVwX3RocmVzaCArICgo Y250LnZfZnJlZV90YXJnZXQgLSB2bV9wYWdlb3V0X3dha2V1cF90aHJlc2gpIC8gMik7CiB9CiBT WVNJTklUKGFyY19mcmVlX3RhcmdldF9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRF Ul9BTlksCiAgICAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIE5VTEwpOwpAQCAtMjYxLDcgKzI3MCw5 IEBACiBTWVNDVExfSU5UKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX3Nocmlua19zaGlmdCwgQ1RM RkxBR19SVywKICAgICAmYXJjX3Nocmlua19zaGlmdCwgMCwKICAgICAibG9nMihmcmFjdGlvbiBv ZiBhcmMgdG8gcmVjbGFpbSkiKTsKLQorU1lTQ1RMX0lOVChfdmZzX3pmcywgT0lEX0FVVE8sIGR5 bmFtaWNfd3JpdGVfYnVmZmVyLCBDVExGTEFHX1JXVFVOLAorICAgICZ6ZnNfZHluYW1pY193cml0 ZV9idWZmZXIsIDAsCisgICAgIkR5bmFtaWNhbGx5IHJlc3RyaWN0IGRpcnR5IGRhdGEgd2hlbiBt ZW1vcnkgaXMgbG93Iik7CiAvKgogICogV2UgZG9uJ3QgaGF2ZSBhIHR1bmFibGUgZm9yIGFyY19m cmVlX3RhcmdldCBkdWUgdG8gdGhlIGRlcGVuZGVuY3kgb24KICAqIHBhZ2VkYWVtb24gaW5pdGlh bGlzYXRpb24uCkBAIC0zNTE4LDYgKzM1MjksMjkgQEAKIGV4dGVybiBrbWVtX2NhY2hlX3QJKnpp b19kYXRhX2J1Zl9jYWNoZVtdOwogZXh0ZXJuIGttZW1fY2FjaGVfdAkqcmFuZ2Vfc2VnX2NhY2hl OwogCitzdGF0aWMgdm9pZCBfX3VzZWQKK3JlYXBfYXJjX2NhY2hlcygpCit7CisJc2l6ZV90ICAg ICAgICAgIGk7CisJa21lbV9jYWNoZV90ICAgICAgICAgICAgKnByZXZfY2FjaGUgPSBOVUxMOwor CWttZW1fY2FjaGVfdCAgICAgICAgICAgICpwcmV2X2RhdGFfY2FjaGUgPSBOVUxMOworCisJZm9y IChpID0gMDsgaSA8IFNQQV9NQVhCTE9DS1NJWkUgPj4gU1BBX01JTkJMT0NLU0hJRlQ7IGkrKykg eworCQlpZiAoemlvX2J1Zl9jYWNoZVtpXSAhPSBwcmV2X2NhY2hlKSB7CisJCQlwcmV2X2NhY2hl ID0gemlvX2J1Zl9jYWNoZVtpXTsKKwkJCWttZW1fY2FjaGVfcmVhcF9ub3coemlvX2J1Zl9jYWNo ZVtpXSk7CisJCX0KKwkJaWYgKHppb19kYXRhX2J1Zl9jYWNoZVtpXSAhPSBwcmV2X2RhdGFfY2Fj aGUpIHsKKwkJCXByZXZfZGF0YV9jYWNoZSA9IHppb19kYXRhX2J1Zl9jYWNoZVtpXTsKKwkJCWtt ZW1fY2FjaGVfcmVhcF9ub3coemlvX2RhdGFfYnVmX2NhY2hlW2ldKTsKKwkJfQorCX0KKwlrbWVt X2NhY2hlX3JlYXBfbm93KGJ1Zl9jYWNoZSk7CisJa21lbV9jYWNoZV9yZWFwX25vdyhoZHJfZnVs bF9jYWNoZSk7CisJa21lbV9jYWNoZV9yZWFwX25vdyhoZHJfbDJvbmx5X2NhY2hlKTsKKwlrbWVt X2NhY2hlX3JlYXBfbm93KHJhbmdlX3NlZ19jYWNoZSk7Cit9CisKIHN0YXRpYyBfX25vaW5saW5l IHZvaWQKIGFyY19rbWVtX3JlYXBfbm93KHZvaWQpCiB7CkBAIC0zNTQyLDIwICszNTc2LDcgQEAK ICNlbmRpZgogI2VuZGlmCiAKLQlmb3IgKGkgPSAwOyBpIDwgU1BBX01BWEJMT0NLU0laRSA+PiBT UEFfTUlOQkxPQ0tTSElGVDsgaSsrKSB7Ci0JCWlmICh6aW9fYnVmX2NhY2hlW2ldICE9IHByZXZf Y2FjaGUpIHsKLQkJCXByZXZfY2FjaGUgPSB6aW9fYnVmX2NhY2hlW2ldOwotCQkJa21lbV9jYWNo ZV9yZWFwX25vdyh6aW9fYnVmX2NhY2hlW2ldKTsKLQkJfQotCQlpZiAoemlvX2RhdGFfYnVmX2Nh Y2hlW2ldICE9IHByZXZfZGF0YV9jYWNoZSkgewotCQkJcHJldl9kYXRhX2NhY2hlID0gemlvX2Rh dGFfYnVmX2NhY2hlW2ldOwotCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6aW9fZGF0YV9idWZfY2Fj aGVbaV0pOwotCQl9Ci0JfQotCWttZW1fY2FjaGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKLQlrbWVt X2NhY2hlX3JlYXBfbm93KGhkcl9mdWxsX2NhY2hlKTsKLQlrbWVtX2NhY2hlX3JlYXBfbm93KGhk cl9sMm9ubHlfY2FjaGUpOwotCWttZW1fY2FjaGVfcmVhcF9ub3cocmFuZ2Vfc2VnX2NhY2hlKTsK KwlyZWFwX2FyY19jYWNoZXMoKTsKIAogI2lmZGVmIGlsbHVtb3MKIAlpZiAoemlvX2FyZW5hICE9 IE5VTEwpIHsKQEAgLTM1OTAsMTEgKzM2MTEsMjggQEAKIHsKIAljbG9ja190CQkJZ3Jvd3RpbWUg PSAwOwogCWNhbGxiX2Nwcl90CQljcHI7CisJaW50CQkJYXV0b3JlYXAgPSAwOwogCiAJQ0FMTEJf Q1BSX0lOSVQoJmNwciwgJmFyY19yZWNsYWltX2xvY2ssIGNhbGxiX2dlbmVyaWNfY3ByLCBGVEFH KTsKIAogCW11dGV4X2VudGVyKCZhcmNfcmVjbGFpbV9sb2NrKTsKIAl3aGlsZSAoIWFyY19yZWNs YWltX3RocmVhZF9leGl0KSB7CisjaWZkZWYgX0tFUk5FTAorLyogS0QgMjAxNS0wMi0xMAorICog UHJvdGVjdCBhZ2FpbnN0IFVNQSBmcmVlIG1lbW9yeSBibG9hdC4gIFdlIGFscmVhZHkgZG8gdGhp cyBvbiBhIGxvdy1tZW1vcnkKKyAqIGJhc2lzIGluIHRoZSBhbGxvY2F0b3I7IGl0IGhhcyB0byBo YXBwZW4gdGhlcmUgcmF0aGVyIHRoYW4gaGVyZSBkdWUgdG8KKyAqIHJlc3BvbnNlIHRpbWUgY29u c2lkZXJhdGlvbnMuICBNYWtlIHRoZSBjYWxsIGhlcmUgb25jZSBldmVyeSAxMCBwYXNzZXMgYXMK KyAqIHdlbGw7IHRoaXMgcmVjbGFpbXMgdW51c2VkIFVNQSBidWZmZXJzIGV2ZXJ5IDEwIHNlY29u ZHMgb24gYW4gaWRsZSBzeXN0ZW0KKyAqIGFuZCBtb3JlIGZyZXF1ZW50bHkgaWYgdGhlIHJlY2xh aW0gdGhyZWFkIGdldHMgd29rZW4gdXAgYnkgbG93IFJBTQorICogY29uZGl0aW9ucy4KKyAqLwor CQlpZiAoKHppb191c2VfdW1hKSAmJiAoYXV0b3JlYXArKyA9PSAxMCkpIHsKKwkJCWF1dG9yZWFw ID0gMDsKKwkJCURUUkFDRV9QUk9CRShhcmNfX3JlY2xhaW1fdGltZWRfcmVhcCk7CisJCQlyZWFw X2FyY19jYWNoZXMoKTsKKwkJfQorI2VuZGlmIC8qIF9LRVJORUwgKi8KKwogCQlpbnQ2NF90IGZy ZWVfbWVtb3J5ID0gYXJjX2F2YWlsYWJsZV9tZW1vcnkoKTsKIAkJdWludDY0X3QgZXZpY3RlZCA9 IDA7CiAKQEAgLTM4NjAsNiArMzg5OSwxOSBAQAogCQlhcmNfc3BhY2VfY29uc3VtZShzaXplLCBB UkNfU1BBQ0VfTUVUQSk7CiAJfSBlbHNlIHsKIAkJQVNTRVJUKHR5cGUgPT0gQVJDX0JVRkNfREFU QSk7CisjaWZkZWYgX0tFUk5FTAorLyogS0QgMjAxNS0wMi0xMAorICogSXQgd291bGQgYmUgbmlj ZSBpZiB3ZSBjb3VsZCBsZWF2ZSB0aGlzIHRvIHRoZSBhcmNfcmVjbGFpbSB0aHJlYWQuCisgKiBV bmZvcnR1bmF0ZWx5IHdlIGNhbm5vdDsgdGhlIHRlc3QgaGFzIHRvIGJlIGRvbmUgaGVyZSBhcyB3 ZWxsLCBiZWNhdXNlCisgKiB1bmRlciBoZWF2eSBJL08gZGVtYW5kIHdlIGNhbiBncmFiIGVub3Vn aCBSQU0gZmFzdCBlbm91Z2ggdG8gaW5kdWNlCisgKiBuYXN0eSBvc2NpbGxhdGlvbiBwcm9ibGVt cy4gIEZvcnR1bmF0ZWx5IHdlIG9ubHkgbmVlZCB0byBjYWxsIHRoaXMgd2hlbgorICogdGhlIHN5 c3RlbSBpcyB1bmRlciByZWFzb25hYmx5LXNldmVyZSBtZW1vcnkgc3RyZXNzLgorICovCisJCWlm ICh6aW9fdXNlX3VtYSAmJiAocHRvYihjbnQudl9mcmVlX2NvdW50KSArIHNpemUgPCBwdG9iKGNu dC52X2ZyZWVfdGFyZ2V0KSkpIHsKKwkJCURUUkFDRV9QUk9CRTMoYXJjX19hbGxvY19sb3dtZW1f cmVhcCwgaW50LCBjbnQudl9mcmVlX2NvdW50LCBpbnQsIHNpemUsIGludCwgY250LnZfZnJlZV90 YXJnZXQpOworCQkJcmVhcF9hcmNfY2FjaGVzKCk7CisJCX0KKyNlbmRpZiAvKiBfS0VSTkVMICov CiAJCWJ1Zi0+Yl9kYXRhID0gemlvX2RhdGFfYnVmX2FsbG9jKHNpemUpOwogCQlhcmNfc3BhY2Vf Y29uc3VtZShzaXplLCBBUkNfU1BBQ0VfREFUQSk7CiAJfQpJbmRleDogc3lzL2NkZGwvY29udHJp Yi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9kbXVfdHguYwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBz eXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90eC5jCShy ZXZpc2lvbiAyODY3OTUpCisrKyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21t b24vZnMvemZzL2RtdV90eC5jCSh3b3JraW5nIGNvcHkpCkBAIC00Miw2ICs0Miw4IEBACiB0eXBl ZGVmIHZvaWQgKCpkbXVfdHhfaG9sZF9mdW5jX3QpKGRtdV90eF90ICp0eCwgc3RydWN0IGRub2Rl ICpkbiwKICAgICB1aW50NjRfdCBhcmcxLCB1aW50NjRfdCBhcmcyKTsKIAorZXh0ZXJuCWludAl6 aW9fdXNlX3VtYTsJLyogTmVlZHMgdG8gYmUgdmlzaWJsZTsgRE8gTk9UIE1PRElGWSEgKi8KK2lu dAl6ZnNfZHluYW1pY193cml0ZV9idWZmZXIgPSAxOwkvKiBEeW5hbWljYWxseSB0dW5lIHdyaXRl cyAqLwogCiBkbXVfdHhfdCAqCiBkbXVfdHhfY3JlYXRlX2RkKGRzbF9kaXJfdCAqZGQpCkBAIC0x MDYwLDcgKzEwNjIsNyBAQAogewogCWRzbF9wb29sX3QgKmRwID0gdHgtPnR4X3Bvb2w7CiAJdWlu dDY0X3QgZGVsYXlfbWluX2J5dGVzID0KLQkgICAgemZzX2RpcnR5X2RhdGFfbWF4ICogemZzX2Rl bGF5X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOworCSAgICB6ZnNfZGlydHlfZGF0YV9tYXhfaW50 ZXJuYWwgKiB6ZnNfZGVsYXlfbWluX2RpcnR5X3BlcmNlbnQgLyAxMDA7CiAJaHJ0aW1lX3Qgd2Fr ZXVwLCBtaW5fdHhfdGltZSwgbm93OwogCiAJaWYgKGRpcnR5IDw9IGRlbGF5X21pbl9ieXRlcykK QEAgLTEwNzIsMTEgKzEwNzQsMTEgQEAKIAkgKiBoYXZlIHRvIGhhbmRsZSB0aGUgY2FzZSBvZiBp dCBiZWluZyA+PSB0aGUgbWF4LCB3aGljaCBjb3VsZAogCSAqIGNhdXNlIGEgZGl2aWRlLWJ5LXpl cm8gaWYgaXQncyA9PSB0aGUgbWF4LgogCSAqLwotCUFTU0VSVDNVKGRpcnR5LCA8LCB6ZnNfZGly dHlfZGF0YV9tYXgpOworCUFTU0VSVDNVKGRpcnR5LCA8LCB6ZnNfZGlydHlfZGF0YV9tYXhfaW50 ZXJuYWwpOwogCiAJbm93ID0gZ2V0aHJ0aW1lKCk7CiAJbWluX3R4X3RpbWUgPSB6ZnNfZGVsYXlf c2NhbGUgKgotCSAgICAoZGlydHkgLSBkZWxheV9taW5fYnl0ZXMpIC8gKHpmc19kaXJ0eV9kYXRh X21heCAtIGRpcnR5KTsKKwkgICAgKGRpcnR5IC0gZGVsYXlfbWluX2J5dGVzKSAvICh6ZnNfZGly dHlfZGF0YV9tYXhfaW50ZXJuYWwgLSBkaXJ0eSk7CiAJaWYgKG5vdyA+IHR4LT50eF9zdGFydCAr IG1pbl90eF90aW1lKQogCQlyZXR1cm47CiAKQEAgLTEyODEsNiArMTI4Myw3IEBACiBkbXVfdHhf YXNzaWduKGRtdV90eF90ICp0eCwgdHhnX2hvd190IHR4Z19ob3cpCiB7CiAJaW50IGVycjsKKwlz dGF0aWMJdWludDY0X3QJbGFzdF9tYXg7CiAKIAlBU1NFUlQodHgtPnR4X3R4ZyA9PSAwKTsKIAlB U1NFUlQodHhnX2hvdyA9PSBUWEdfV0FJVCB8fCB0eGdfaG93ID09IFRYR19OT1dBSVQgfHwKQEAg LTEyOTMsNiArMTI5Niw0MiBAQAogCWlmICh0eGdfaG93ID09IFRYR19XQUlURUQpCiAJCXR4LT50 eF93YWl0ZWQgPSBCX1RSVUU7CiAKKyNpZmRlZiBfS0VSTkVMCisJLyoKKwkgKiBLRCAyMDE0LTA5 LTIyCisJICogSWYgVU1BIGlzIGVuYWJsZWQgaXQgY2FuIG9ubHkgcmV0dXJuIGEgcHJldmlvdXNs eS11c2VkIGJsb2NrCisJICogb2YgaWRlbnRpY2FsIHNpemUgdG8gd2hhdCBpdCBoYWQgb3V0IGJl Zm9yZS4gIElmIGl0J3Mgbm90IHRoZQorCSAqIHNhbWUgc2l6ZSBpdCB3aWxsIGFsbG9jYXRlIGEg bmV3IG9uZS4gIFRoaXMgaXMgYSBwcm9ibGVtIGJlY2F1c2UKKwkgKiBkaXJ0eV9kYXRhX21heCBp cyB0aGUgdG90YWwgZGlydHkgd3JpdGUgZGF0YSBhbGxvd2VkIG91dCBhdCBhbnkKKwkgKiBnaXZl biB0aW1lLCBidXQgd2l0aCBVTUEgb24gdGhhdCBjYW4gbXVsdGlwbHkgYnkgdGhlIG51bWJlciBv ZgorCSAqIGRpZmZlcmVudCBibG9jayBzaXplcyAoISEpIHJlcXVlc3RlZCBpbiB0ZXJtcyBvZiBm cmVlIFJBTSB0aGF0CisJICogaXMgbGVmdCBhbGxvY2F0ZWQgYnV0IHVudXNlZC4gIEZvciB0aGlz IHJlYXNvbiBuZXZlciBhbGxvdworCSAqIGRpcnR5X2RhdGFfbWF4IHRvIGV4Y2VlZCB0aGUgZGlm ZmVyZW5jZSBiZXR3ZWVuIHRoZSBwYWdpbmcKKwkgKiB0aHJlc2hvbGQgYW5kIHRoZSBjdXJyZW50 IGZyZWUgbWVtb3J5LCB3aXRoIGEgbWluaW11bSBvZiAyNTZNQi4KKwkgKiBUaGlzIHRocm90dGxl cyAiYnVyc3QiIGFsbG9jYXRpb25zIGFuZCBwcmV2ZW50cyB0aGUgc3lzdGVtIGZyb20KKwkgKiBj aG9raW5nIGR1cmluZyB0aW1lcyBvZiBoaWdoIHdyaXRlIEkvTyBkZW1hbmQuCisJICoKKwkgKiBX ZSBhbGxvdyB0aGlzIHRvIGJlIHR1cm5lZCBvZmYgaWYgeW91IHdhbnQgd2l0aAorCSAqICJ2ZnMu emZzX2R5bmFtaWNfd3JpdGVfYnVmZmVyPTAiLCB3aGljaCBjYW4gYmUgZG9uZSBpbiByZWFsIHRp bWUuCisJICoKKwkgKiBOb3RlIHRoYXQgd2Ugd29yayBvbiB0aGUgemZzX2RpcnR5X2RhdGFfbWF4 X2ludGVybmFsIHZhcmlhYmxlLAorCSAqIGJlY2F1c2UgdGhlIHVzZXIgbWF5IHNldCB6ZnNfZGly dHlfZGF0YV9tYXggaGltc2VsZiBhbmQgd2UgbXVzdAorCSAqIG11c3QgaG9ub3IgdGhhdCBhcyBh IGhhcmQgY2FwIHNvIGl0IHJlbWFpbnMgYSB1c2FibGUgdHVuYWJsZSB2YWx1ZS4KKwkgKi8KKwlp ZiAoemlvX3VzZV91bWEgJiB6ZnNfZHluYW1pY193cml0ZV9idWZmZXIpIHsKKwkJemZzX2RpcnR5 X2RhdGFfbWF4X2ludGVybmFsID0gMSA8PCAyODsKKwkJemZzX2RpcnR5X2RhdGFfbWF4X2ludGVy bmFsID0gTUFYKHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCwgcHRvYihjbnQudl9mcmVlX2Nv dW50IC0gY250LnZfZnJlZV90YXJnZXQpKTsKKwkJemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFs ID0gTUlOKHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCwgemZzX2RpcnR5X2RhdGFfbWF4KTsK KwkJemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsID0gTUlOKHpmc19kaXJ0eV9kYXRhX21heF9p bnRlcm5hbCwgemZzX2RpcnR5X2RhdGFfbWF4X21heCk7CisJCWlmIChsYXN0X21heCAhPSAoemZz X2RpcnR5X2RhdGFfbWF4X2ludGVybmFsIC8gKDEwMjQgKiAxMDI0KSkpIHsKKwkJCWxhc3RfbWF4 ID0gemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsIC8gKDEwMjQgKiAxMDI0KTsKKwkJCURUUkFD RV9QUk9CRTEoZG11X190eF9kaXJ0eSwgdWludDY0X3QsIGxhc3RfbWF4KTsKKwkJfQorCX0gZWxz ZSB7CisJCXpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCA9IHpmc19kaXJ0eV9kYXRhX21heDsK Kwl9CisjZW5kaWYgLyogX0tFUk5FTCAqLworCiAJd2hpbGUgKChlcnIgPSBkbXVfdHhfdHJ5X2Fz c2lnbih0eCwgdHhnX2hvdykpICE9IDApIHsKIAkJZG11X3R4X3VuYXNzaWduKHR4KTsKIApAQCAt MTMyMyw3ICsxMzYyLDcgQEAKIAkJICogc3BhY2UuCiAJCSAqLwogCQltdXRleF9lbnRlcigmZHAt PmRwX2xvY2spOwotCQl3aGlsZSAoZHAtPmRwX2RpcnR5X3RvdGFsID49IHpmc19kaXJ0eV9kYXRh X21heCkKKwkJd2hpbGUgKGRwLT5kcF9kaXJ0eV90b3RhbCA+PSB6ZnNfZGlydHlfZGF0YV9tYXhf aW50ZXJuYWwpCiAJCQljdl93YWl0KCZkcC0+ZHBfc3BhY2VhdmFpbF9jdiwgJmRwLT5kcF9sb2Nr KTsKIAkJdWludDY0X3QgZGlydHkgPSBkcC0+ZHBfZGlydHlfdG90YWw7CiAJCW11dGV4X2V4aXQo JmRwLT5kcF9sb2NrKTsKSW5kZXg6IHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2Nv bW1vbi9mcy96ZnMvZHNsX3Bvb2wuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29w ZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RzbF9wb29sLmMJKHJldmlzaW9uIDI4Njc5NSkK KysrIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZHNsX3Bv b2wuYwkod29ya2luZyBjb3B5KQpAQCAtOTgsOCArOTgsMTEgQEAKIC8qCiAgKiB6ZnNfZGlydHlf ZGF0YV9tYXggd2lsbCBiZSBzZXQgdG8gemZzX2RpcnR5X2RhdGFfbWF4X3BlcmNlbnQlIG9mIGFs bCBtZW1vcnksCiAgKiBjYXBwZWQgYXQgemZzX2RpcnR5X2RhdGFfbWF4X21heC4gIEl0IGNhbiBh bHNvIGJlIG92ZXJyaWRkZW4gaW4gL2V0Yy9zeXN0ZW0uCisgKiBXZSBhbHNvIGR5bmFtaWNhbGx5 IHR1bmUgZHVyaW5nIGxvdyBtZW1vcnksIGhvbm9yaW5nIHRoZSBzeXNjdGwgc2V0LCBzbworICog aW50ZXJuYWwgY29tcGFyaXNvbnMgYXJlIGFnYWluc3QgemZzX2RpcnR5X2RhdGFfbWF4X2ludGVy bmFsLgogICovCiB1aW50NjRfdCB6ZnNfZGlydHlfZGF0YV9tYXg7Cit1aW50NjRfdCB6ZnNfZGly dHlfZGF0YV9tYXhfaW50ZXJuYWw7CiB1aW50NjRfdCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4ID0g NFVMTCAqIDEwMjQgKiAxMDI0ICogMTAyNDsKIGludCB6ZnNfZGlydHlfZGF0YV9tYXhfcGVyY2Vu dCA9IDEwOwogCkBAIC01NTMsNyArNTU2LDcgQEAKIAkgKiBOb3RlOiB3ZSBzaWduYWwgZXZlbiB3 aGVuIGluY3JlYXNpbmcgZHBfZGlydHlfdG90YWwuCiAJICogVGhpcyBlbnN1cmVzIGZvcndhcmQg cHJvZ3Jlc3MgLS0gZWFjaCB0aHJlYWQgd2FrZXMgdGhlIG5leHQgd2FpdGVyLgogCSAqLwotCWlm IChkcC0+ZHBfZGlydHlfdG90YWwgPD0gemZzX2RpcnR5X2RhdGFfbWF4KQorCWlmIChkcC0+ZHBf ZGlydHlfdG90YWwgPD0gemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsKQogCQljdl9zaWduYWwo JmRwLT5kcF9zcGFjZWF2YWlsX2N2KTsKIH0KIApAQCAtNzMyLDcgKzczNSw3IEBACiBkc2xfcG9v bF9uZWVkX2RpcnR5X2RlbGF5KGRzbF9wb29sX3QgKmRwKQogewogCXVpbnQ2NF90IGRlbGF5X21p bl9ieXRlcyA9Ci0JICAgIHpmc19kaXJ0eV9kYXRhX21heCAqIHpmc19kZWxheV9taW5fZGlydHlf cGVyY2VudCAvIDEwMDsKKwkgICAgemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsICogemZzX2Rl bGF5X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOwogCWJvb2xlYW5fdCBydjsKIAogCW11dGV4X2Vu dGVyKCZkcC0+ZHBfbG9jayk7CkluZGV4OiBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0 cy9jb21tb24vZnMvemZzL3N5cy9kc2xfcG9vbC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9jZGRsL2Nv bnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvc3lzL2RzbF9wb29sLmgJKHJldmlz aW9uIDI4Njc5NSkKKysrIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9m cy96ZnMvc3lzL2RzbF9wb29sLmgJKHdvcmtpbmcgY29weSkKQEAgLTUwLDYgKzUwLDcgQEAKIHN0 cnVjdCBkc2xfc2NhbjsKIAogZXh0ZXJuIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heDsKK2V4 dGVybiB1aW50NjRfdCB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWw7CiBleHRlcm4gdWludDY0 X3QgemZzX2RpcnR5X2RhdGFfbWF4X21heDsKIGV4dGVybiB1aW50NjRfdCB6ZnNfZGlydHlfZGF0 YV9zeW5jOwogZXh0ZXJuIGludCB6ZnNfZGlydHlfZGF0YV9tYXhfcGVyY2VudDsKSW5kZXg6IHN5 cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvemlvLmMKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy96 aW8uYwkocmV2aXNpb24gMjg2Nzk1KQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91 dHMvY29tbW9uL2ZzL3pmcy96aW8uYwkod29ya2luZyBjb3B5KQpAQCAtNDMsMTAgKzQzLDEzIEBA CiAKIFNZU0NUTF9ERUNMKF92ZnNfemZzKTsKIFNZU0NUTF9OT0RFKF92ZnNfemZzLCBPSURfQVVU TywgemlvLCBDVExGTEFHX1JXLCAwLCAiWkZTIFpJTyIpOworLyogS0QgMjAxNS0wNy0xNSBDaGFu Z2UgY2xhc3MgdG8gImludCIgZnJvbSAic3RhdGljIGludCIgYXMgd2UgcmVmZXJlbmNlIAorICog dGhpcyBhcyBhbiBleHRlcm4gZWxzZXdoZXJlCisgKi8KICNpZiBkZWZpbmVkKF9fYW1kNjRfXykK LXN0YXRpYyBpbnQgemlvX3VzZV91bWEgPSAxOworaW50IHppb191c2VfdW1hID0gMTsKICNlbHNl Ci1zdGF0aWMgaW50IHppb191c2VfdW1hID0gMDsKK2ludCB6aW9fdXNlX3VtYSA9IDA7CiAjZW5k aWYKIFNZU0NUTF9JTlQoX3Zmc196ZnNfemlvLCBPSURfQVVUTywgdXNlX3VtYSwgQ1RMRkxBR19S RFRVTiwgJnppb191c2VfdW1hLCAwLAogICAgICJVc2UgdW1hKDkpIGZvciBaSU8gYWxsb2NhdGlv bnMiKTsK 161692 2015-10-04 12:00:55 +0000 2015-10-04 12:00:55 +0000 ARC Refactor / UMA Cleardown / DMU_TX dynamic with time-based rate limiting against stable/10 after r288599 patch.combo.stable10.r288599 text/plain 11944 junchoon SW5kZXg6IHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvYXJj LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9u L2ZzL3pmcy9hcmMuYwkocmV2aXNpb24gMjg4NjAwKQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVu c29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMjE2LDYg KzIxNiwxNSBAQAogZXh0ZXJuIGJvb2xlYW5fdCB6ZnNfcHJlZmV0Y2hfZGlzYWJsZTsKIAogLyoK KyAqIEtEIDIwMTUtMDItMTAKKyAqIFdlIGhhdmUgdG8gYmUgYWJsZSB0byB0ZXN0IGZvciBVSU8g dXNlIGluc2lkZSB0aGUgYXJjIGFsbG9jYXRvci4KKyAqIE5PVEU6IERPIE5PVCBNT0RJRlkgSEVS RSEKKyAqLworZXh0ZXJuIGludCB6aW9fdXNlX3VtYTsKK2V4dGVybiBpbnQgemZzX2R5bmFtaWNf d3JpdGVfYnVmZmVyOworCisKKy8qCiAgKiBUaGUgYXJjIGhhcyBmaWxsZWQgYXZhaWxhYmxlIG1l bW9yeSBhbmQgaGFzIG5vdyB3YXJtZWQgdXAuCiAgKi8KIHN0YXRpYyBib29sZWFuX3QgYXJjX3dh cm07CkBAIC0yNDIsNyArMjUxLDcgQEAKIGFyY19mcmVlX3RhcmdldF9pbml0KHZvaWQgKnVudXNl ZCBfX3VudXNlZCkKIHsKIAotCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2bV9wYWdlb3V0X3dha2V1 cF90aHJlc2g7CisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2VvdXRfd2FrZXVwX3RocmVz aCArICgoY250LnZfZnJlZV90YXJnZXQgLSB2bV9wYWdlb3V0X3dha2V1cF90aHJlc2gpIC8gMik7 CiB9CiBTWVNJTklUKGFyY19mcmVlX3RhcmdldF9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBT SV9PUkRFUl9BTlksCiAgICAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIE5VTEwpOwpAQCAtMjY0LDcg KzI3Myw5IEBACiBTWVNDVExfSU5UKF92ZnNfemZzLCBPSURfQVVUTywgYXJjX3Nocmlua19zaGlm dCwgQ1RMRkxBR19SVywKICAgICAmYXJjX3Nocmlua19zaGlmdCwgMCwKICAgICAibG9nMihmcmFj dGlvbiBvZiBhcmMgdG8gcmVjbGFpbSkiKTsKLQorU1lTQ1RMX0lOVChfdmZzX3pmcywgT0lEX0FV VE8sIGR5bmFtaWNfd3JpdGVfYnVmZmVyLCBDVExGTEFHX1JXVFVOLAorICAgICZ6ZnNfZHluYW1p Y193cml0ZV9idWZmZXIsIDAsCisgICAgIkR5bmFtaWNhbGx5IHJlc3RyaWN0IGRpcnR5IGRhdGEg d2hlbiBtZW1vcnkgaXMgbG93Iik7CiAvKgogICogV2UgZG9uJ3QgaGF2ZSBhIHR1bmFibGUgZm9y IGFyY19mcmVlX3RhcmdldCBkdWUgdG8gdGhlIGRlcGVuZGVuY3kgb24KICAqIHBhZ2VkYWVtb24g aW5pdGlhbGlzYXRpb24uCkBAIC0zNTI0LDYgKzM1MzUsNDIgQEAKIGV4dGVybiBrbWVtX2NhY2hl X3QJKnppb19kYXRhX2J1Zl9jYWNoZVtdOwogZXh0ZXJuIGttZW1fY2FjaGVfdAkqcmFuZ2Vfc2Vn X2NhY2hlOwogCisvKgorICogVXNlZCBieSBhcmNfa21lbV9yZWFwX25vdygpIGFuZCBjb25zaWRl cl9yZWFwaW5nX2FyY19jYWNoZXMoKQorICogdG8gbGltaXQgdGhlIHRpbWUgc3BlbnQgcmVhcGlu Zy4KKyAqCisgKiBUaGUgYXJjX3JlYXBpbmdfaW5fcHJvZ3Jlc3MgaXMgYSAoc29tZXdoYXQgcmFj eSkgbGVmdCBvdmVyIGZyb20gYQorICogcHJldmlvdXMgdmVyc2lvbiBvZiB0aGlzIGNvZGUgd2hp Y2ggY291bGQgdHJpZ2dlciBtdWx0aXBsZSBBUkMgY2FjaGUKKyAqIHJlYXBpbmdzIGluIHBhcmFs bGVsIHdoaWNoIHNob3VsZCBiZSBhdm9pZGVkIHRvIHJlZHVjZSBsb2NrCisgKiBjb250ZW50aW9u LiBJdCdzIGhhc24ndCBiZWVuIHJlbW92ZWQgeWV0IHRvIGVuY291cmFnZSBmdXJ0aGVyCisgKiBl eHBlcmltZW50aW5nLgorICovCitzdGF0aWMgdW5zaWduZWQgaW50IGFyY19yZWFwaW5nX2luX3By b2dyZXNzID0gMDsKK3N0YXRpYyBzYmludGltZV90IGxhc3RfcmVhcGluZyA9IDA7CisKK3N0YXRp YyB2b2lkIF9fbm9pbmxpbmUKK3JlYXBfYXJjX2NhY2hlcyh2b2lkKQoreworCXNpemVfdCAgICAg ICAgICBpOworCWttZW1fY2FjaGVfdCAgICAgICAgICAgICpwcmV2X2NhY2hlID0gTlVMTDsKKwlr bWVtX2NhY2hlX3QgICAgICAgICAgICAqcHJldl9kYXRhX2NhY2hlID0gTlVMTDsKKworCWZvciAo aSA9IDA7IGkgPCBTUEFfTUFYQkxPQ0tTSVpFID4+IFNQQV9NSU5CTE9DS1NISUZUOyBpKyspIHsK KwkJaWYgKHppb19idWZfY2FjaGVbaV0gIT0gcHJldl9jYWNoZSkgeworCQkJcHJldl9jYWNoZSA9 IHppb19idWZfY2FjaGVbaV07CisJCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19idWZfY2FjaGVb aV0pOworCQl9CisJCWlmICh6aW9fZGF0YV9idWZfY2FjaGVbaV0gIT0gcHJldl9kYXRhX2NhY2hl KSB7CisJCQlwcmV2X2RhdGFfY2FjaGUgPSB6aW9fZGF0YV9idWZfY2FjaGVbaV07CisJCQlrbWVt X2NhY2hlX3JlYXBfbm93KHppb19kYXRhX2J1Zl9jYWNoZVtpXSk7CisJCX0KKwl9CisJa21lbV9j YWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOworCWttZW1fY2FjaGVfcmVhcF9ub3coaGRyX2Z1bGxf Y2FjaGUpOworCWttZW1fY2FjaGVfcmVhcF9ub3coaGRyX2wyb25seV9jYWNoZSk7CisJa21lbV9j YWNoZV9yZWFwX25vdyhyYW5nZV9zZWdfY2FjaGUpOworfQorCiBzdGF0aWMgX19ub2lubGluZSB2 b2lkCiBhcmNfa21lbV9yZWFwX25vdyh2b2lkKQogewpAQCAtMzUzMiw2ICszNTc5LDggQEAKIAlr bWVtX2NhY2hlX3QJCSpwcmV2X2RhdGFfY2FjaGUgPSBOVUxMOwogCiAJRFRSQUNFX1BST0JFKGFy Y19fa21lbV9yZWFwX3N0YXJ0KTsKKwlhcmNfcmVhcGluZ19pbl9wcm9ncmVzcysrOworCiAjaWZk ZWYgX0tFUk5FTAogCWlmIChhcmNfbWV0YV91c2VkID49IGFyY19tZXRhX2xpbWl0KSB7CiAJCS8q CkBAIC0zNTQ4LDIwICszNTk3LDcgQEAKICNlbmRpZgogI2VuZGlmCiAKLQlmb3IgKGkgPSAwOyBp IDwgU1BBX01BWEJMT0NLU0laRSA+PiBTUEFfTUlOQkxPQ0tTSElGVDsgaSsrKSB7Ci0JCWlmICh6 aW9fYnVmX2NhY2hlW2ldICE9IHByZXZfY2FjaGUpIHsKLQkJCXByZXZfY2FjaGUgPSB6aW9fYnVm X2NhY2hlW2ldOwotCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6aW9fYnVmX2NhY2hlW2ldKTsKLQkJ fQotCQlpZiAoemlvX2RhdGFfYnVmX2NhY2hlW2ldICE9IHByZXZfZGF0YV9jYWNoZSkgewotCQkJ cHJldl9kYXRhX2NhY2hlID0gemlvX2RhdGFfYnVmX2NhY2hlW2ldOwotCQkJa21lbV9jYWNoZV9y ZWFwX25vdyh6aW9fZGF0YV9idWZfY2FjaGVbaV0pOwotCQl9Ci0JfQotCWttZW1fY2FjaGVfcmVh cF9ub3coYnVmX2NhY2hlKTsKLQlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9mdWxsX2NhY2hlKTsK LQlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9sMm9ubHlfY2FjaGUpOwotCWttZW1fY2FjaGVfcmVh cF9ub3cocmFuZ2Vfc2VnX2NhY2hlKTsKKwlyZWFwX2FyY19jYWNoZXMoKTsKIAogI2lmZGVmIHN1 bgogCWlmICh6aW9fYXJlbmEgIT0gTlVMTCkgewpAQCAtMzU3MiwxMCArMzYwOCw1MSBAQAogCQl2 bWVtX3FjYWNoZV9yZWFwKHppb19hcmVuYSk7CiAJfQogI2VuZGlmCisjaWZkZWYgX0tFUk5FTAor CWxhc3RfcmVhcGluZyA9IGdldHNiaW51cHRpbWUoKTsKKyNlbmRpZgorCWFyY19yZWFwaW5nX2lu X3Byb2dyZXNzID0gMDsKIAlEVFJBQ0VfUFJPQkUoYXJjX19rbWVtX3JlYXBfZW5kKTsKIH0KIAor CiAvKgorICogRGVjbGFyZWQgd3JpdGFibGUgdG8gYWxsb3cgcmVzZXR0aW5nIGl0LgorICogWFhY OiBTaG91bGQgcHJvYmFibHkgYmUgYSB1aW50NjQgYW5kIGludGVncmF0ZWQgd2l0aCBrc3RhdC4K KyAqLworc3RhdGljIHVuc2lnbmVkIGludCBhcmNfY2FjaGVfcmVhcGluZ3Nfc2tpcHBlZCA9IDA7 CitTWVNDVExfVUlOVChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19jYWNoZV9yZWFwaW5nc19za2lw cGVkLCBDVExGTEFHX1JXLAorICAgICZhcmNfY2FjaGVfcmVhcGluZ3Nfc2tpcHBlZCwgMCwgIk51 bWJlciBvZiB0aW1lcyB0aGUgQVJDIGNhY2hlcyBoYXZlIG5vdCBiZWVuIHJlYXBlZCBkdWUgdG8g dGhlIHJlYXAgZGVsYXkiKTsKKworc3RhdGljIHVuc2lnbmVkIGludCBtaW5fYXJjX3JlYXBfZGVs YXkgPSAyMDA7CitTWVNDVExfVUlOVChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19yZWFwX2RlbGF5 X21pbiwgQ1RMRkxBR19SVywKKyAgICAmbWluX2FyY19yZWFwX2RlbGF5LCAyMDAsICJNaW5pbXVt IGRlbGF5IGJldHdlZW4gQVJDIGNhY2hlIHJlYXBpbmdzIChtaWxsaXNlY29uZHMpIik7CisKK3N0 YXRpYyB2b2lkIF9fbm9pbmxpbmUKK2NvbnNpZGVyX3JlYXBpbmdfYXJjX2NhY2hlcyh2b2lkKQor eworI2lmZGVmIF9LRVJORUwKKwlzYmludGltZV90IG5vdzsKKworCWlmIChhcmNfcmVhcGluZ19p bl9wcm9ncmVzcykKKwl7CisJCS8qIEFscmVhZHkgcmVhcGluZyBpbiBhbm90aGVyIHRocmVhZC4g Ki8KKwkJYXJjX2NhY2hlX3JlYXBpbmdzX3NraXBwZWQrKzsKKwkJcmV0dXJuOworCX0KKworCW5v dyA9IGdldHNiaW51cHRpbWUoKTsKKwlpZiAoKG5vdyAtIGxhc3RfcmVhcGluZykgLyBTQlRfMU1T IDwgbWluX2FyY19yZWFwX2RlbGF5KQorCXsKKwkJLyogVG9vIHNvb24gdG8gcmVhcCBhZ2Fpbi4g Ki8KKwkJYXJjX2NhY2hlX3JlYXBpbmdzX3NraXBwZWQrKzsKKwkJcmV0dXJuOworCX0KKyNlbmRp ZgorCWFyY19rbWVtX3JlYXBfbm93KCk7Cit9CisKKy8qCiAgKiBUaHJlYWRzIGNhbiBibG9jayBp biBhcmNfZ2V0X2RhdGFfYnVmKCkgd2FpdGluZyBmb3IgdGhpcyB0aHJlYWQgdG8gZXZpY3QKICAq IGVub3VnaCBkYXRhIGFuZCBzaWduYWwgdGhlbSB0byBwcm9jZWVkLiBXaGVuIHRoaXMgaGFwcGVu cywgdGhlIHRocmVhZHMgaW4KICAqIGFyY19nZXRfZGF0YV9idWYoKSBhcmUgc2xlZXBpbmcgd2hp bGUgaG9sZGluZyB0aGUgaGFzaCBsb2NrIGZvciB0aGVpcgpAQCAtMzYxNyw4ICszNjk0LDYgQEAK IAkJCSAqLwogCQkJZ3Jvd3RpbWUgPSBkZGlfZ2V0X2xib2x0KCkgKyAoYXJjX2dyb3dfcmV0cnkg KiBoeik7CiAKLQkJCWFyY19rbWVtX3JlYXBfbm93KCk7Ci0KIAkJCS8qCiAJCQkgKiBJZiB3ZSBh cmUgc3RpbGwgbG93IG9uIG1lbW9yeSwgc2hyaW5rIHRoZSBBUkMKIAkJCSAqIHNvIHRoYXQgd2Ug aGF2ZSBhcmNfc2hyaW5rX21pbiBmcmVlIHNwYWNlLgpAQCAtMzY5Miw2ICszNzY3LDEyIEBACiAJ d2hpbGUgKCFhcmNfdXNlcl9ldmljdHNfdGhyZWFkX2V4aXQpIHsKIAkJbXV0ZXhfZXhpdCgmYXJj X3VzZXJfZXZpY3RzX2xvY2spOwogCisJCS8qCisJCSAqIENvbnNpZGVyIHJlYXBpbmcgdGhlIEFS QyBjYWNoZXMgYXQgbGVhc3Qgb25jZSBwZXIKKwkJICogc2Vjb25kLCBidXQgbW9yZSBvZnRlbiB3 aGVuIHNpZ25hbGxlZCB1bmRlciBwcmVzc3VyZS4KKwkJICovCisJCWNvbnNpZGVyX3JlYXBpbmdf YXJjX2NhY2hlcygpOworCiAJCWFyY19kb191c2VyX2V2aWN0cygpOwogCiAJCS8qCkluZGV4OiBz eXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90eC5jCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96 ZnMvZG11X3R4LmMJKHJldmlzaW9uIDI4ODYwMCkKKysrIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNv bGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZG11X3R4LmMJKHdvcmtpbmcgY29weSkKQEAgLTQyLDYg KzQyLDggQEAKIHR5cGVkZWYgdm9pZCAoKmRtdV90eF9ob2xkX2Z1bmNfdCkoZG11X3R4X3QgKnR4 LCBzdHJ1Y3QgZG5vZGUgKmRuLAogICAgIHVpbnQ2NF90IGFyZzEsIHVpbnQ2NF90IGFyZzIpOwog CitleHRlcm4JaW50CXppb191c2VfdW1hOwkvKiBOZWVkcyB0byBiZSB2aXNpYmxlOyBETyBOT1Qg TU9ESUZZISAqLworaW50CXpmc19keW5hbWljX3dyaXRlX2J1ZmZlciA9IDE7CS8qIER5bmFtaWNh bGx5IHR1bmUgd3JpdGVzICovCiAKIGRtdV90eF90ICoKIGRtdV90eF9jcmVhdGVfZGQoZHNsX2Rp cl90ICpkZCkKQEAgLTEwNjAsNyArMTA2Miw3IEBACiB7CiAJZHNsX3Bvb2xfdCAqZHAgPSB0eC0+ dHhfcG9vbDsKIAl1aW50NjRfdCBkZWxheV9taW5fYnl0ZXMgPQotCSAgICB6ZnNfZGlydHlfZGF0 YV9tYXggKiB6ZnNfZGVsYXlfbWluX2RpcnR5X3BlcmNlbnQgLyAxMDA7CisJICAgIHpmc19kaXJ0 eV9kYXRhX21heF9pbnRlcm5hbCAqIHpmc19kZWxheV9taW5fZGlydHlfcGVyY2VudCAvIDEwMDsK IAlocnRpbWVfdCB3YWtldXAsIG1pbl90eF90aW1lLCBub3c7CiAKIAlpZiAoZGlydHkgPD0gZGVs YXlfbWluX2J5dGVzKQpAQCAtMTA3MiwxMSArMTA3NCwxMSBAQAogCSAqIGhhdmUgdG8gaGFuZGxl IHRoZSBjYXNlIG9mIGl0IGJlaW5nID49IHRoZSBtYXgsIHdoaWNoIGNvdWxkCiAJICogY2F1c2Ug YSBkaXZpZGUtYnktemVybyBpZiBpdCdzID09IHRoZSBtYXguCiAJICovCi0JQVNTRVJUM1UoZGly dHksIDwsIHpmc19kaXJ0eV9kYXRhX21heCk7CisJQVNTRVJUM1UoZGlydHksIDwsIHpmc19kaXJ0 eV9kYXRhX21heF9pbnRlcm5hbCk7CiAKIAlub3cgPSBnZXRocnRpbWUoKTsKIAltaW5fdHhfdGlt ZSA9IHpmc19kZWxheV9zY2FsZSAqCi0JICAgIChkaXJ0eSAtIGRlbGF5X21pbl9ieXRlcykgLyAo emZzX2RpcnR5X2RhdGFfbWF4IC0gZGlydHkpOworCSAgICAoZGlydHkgLSBkZWxheV9taW5fYnl0 ZXMpIC8gKHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCAtIGRpcnR5KTsKIAlpZiAobm93ID4g dHgtPnR4X3N0YXJ0ICsgbWluX3R4X3RpbWUpCiAJCXJldHVybjsKIApAQCAtMTI4MSw2ICsxMjgz LDcgQEAKIGRtdV90eF9hc3NpZ24oZG11X3R4X3QgKnR4LCB0eGdfaG93X3QgdHhnX2hvdykKIHsK IAlpbnQgZXJyOworCXN0YXRpYwl1aW50NjRfdAlsYXN0X21heDsKIAogCUFTU0VSVCh0eC0+dHhf dHhnID09IDApOwogCUFTU0VSVCh0eGdfaG93ID09IFRYR19XQUlUIHx8IHR4Z19ob3cgPT0gVFhH X05PV0FJVCB8fApAQCAtMTI5Myw2ICsxMjk2LDQyIEBACiAJaWYgKHR4Z19ob3cgPT0gVFhHX1dB SVRFRCkKIAkJdHgtPnR4X3dhaXRlZCA9IEJfVFJVRTsKIAorI2lmZGVmIF9LRVJORUwKKwkvKgor CSAqIEtEIDIwMTQtMDktMjIKKwkgKiBJZiBVTUEgaXMgZW5hYmxlZCBpdCBjYW4gb25seSByZXR1 cm4gYSBwcmV2aW91c2x5LXVzZWQgYmxvY2sKKwkgKiBvZiBpZGVudGljYWwgc2l6ZSB0byB3aGF0 IGl0IGhhZCBvdXQgYmVmb3JlLiAgSWYgaXQncyBub3QgdGhlCisJICogc2FtZSBzaXplIGl0IHdp bGwgYWxsb2NhdGUgYSBuZXcgb25lLiAgVGhpcyBpcyBhIHByb2JsZW0gYmVjYXVzZQorCSAqIGRp cnR5X2RhdGFfbWF4IGlzIHRoZSB0b3RhbCBkaXJ0eSB3cml0ZSBkYXRhIGFsbG93ZWQgb3V0IGF0 IGFueQorCSAqIGdpdmVuIHRpbWUsIGJ1dCB3aXRoIFVNQSBvbiB0aGF0IGNhbiBtdWx0aXBseSBi eSB0aGUgbnVtYmVyIG9mCisJICogZGlmZmVyZW50IGJsb2NrIHNpemVzICghISkgcmVxdWVzdGVk IGluIHRlcm1zIG9mIGZyZWUgUkFNIHRoYXQKKwkgKiBpcyBsZWZ0IGFsbG9jYXRlZCBidXQgdW51 c2VkLiAgRm9yIHRoaXMgcmVhc29uIG5ldmVyIGFsbG93CisJICogZGlydHlfZGF0YV9tYXggdG8g ZXhjZWVkIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gdGhlIHBhZ2luZworCSAqIHRocmVzaG9sZCBh bmQgdGhlIGN1cnJlbnQgZnJlZSBtZW1vcnksIHdpdGggYSBtaW5pbXVtIG9mIDI1Nk1CLgorCSAq IFRoaXMgdGhyb3R0bGVzICJidXJzdCIgYWxsb2NhdGlvbnMgYW5kIHByZXZlbnRzIHRoZSBzeXN0 ZW0gZnJvbQorCSAqIGNob2tpbmcgZHVyaW5nIHRpbWVzIG9mIGhpZ2ggd3JpdGUgSS9PIGRlbWFu ZC4KKwkgKgorCSAqIFdlIGFsbG93IHRoaXMgdG8gYmUgdHVybmVkIG9mZiBpZiB5b3Ugd2FudCB3 aXRoCisJICogInZmcy56ZnNfZHluYW1pY193cml0ZV9idWZmZXI9MCIsIHdoaWNoIGNhbiBiZSBk b25lIGluIHJlYWwgdGltZS4KKwkgKgorCSAqIE5vdGUgdGhhdCB3ZSB3b3JrIG9uIHRoZSB6ZnNf ZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgdmFyaWFibGUsCisJICogYmVjYXVzZSB0aGUgdXNlciBt YXkgc2V0IHpmc19kaXJ0eV9kYXRhX21heCBoaW1zZWxmIGFuZCB3ZSBtdXN0CisJICogbXVzdCBo b25vciB0aGF0IGFzIGEgaGFyZCBjYXAgc28gaXQgcmVtYWlucyBhIHVzYWJsZSB0dW5hYmxlIHZh bHVlLgorCSAqLworCWlmICh6aW9fdXNlX3VtYSAmIHpmc19keW5hbWljX3dyaXRlX2J1ZmZlcikg eworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSAxIDw8IDI4OworCQl6ZnNfZGlydHlf ZGF0YV9tYXhfaW50ZXJuYWwgPSBNQVgoemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsLCBwdG9i KGNudC52X2ZyZWVfY291bnQgLSBjbnQudl9mcmVlX3RhcmdldCkpOworCQl6ZnNfZGlydHlfZGF0 YV9tYXhfaW50ZXJuYWwgPSBNSU4oemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsLCB6ZnNfZGly dHlfZGF0YV9tYXgpOworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBNSU4oemZzX2Rp cnR5X2RhdGFfbWF4X2ludGVybmFsLCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4KTsKKwkJaWYgKGxh c3RfbWF4ICE9ICh6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgLyAoMTAyNCAqIDEwMjQpKSkg eworCQkJbGFzdF9tYXggPSB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgLyAoMTAyNCAqIDEw MjQpOworCQkJRFRSQUNFX1BST0JFMShkbXVfX3R4X2RpcnR5LCB1aW50NjRfdCwgbGFzdF9tYXgp OworCQl9CisJfSBlbHNlIHsKKwkJemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsID0gemZzX2Rp cnR5X2RhdGFfbWF4OworCX0KKyNlbmRpZiAvKiBfS0VSTkVMICovCisKIAl3aGlsZSAoKGVyciA9 IGRtdV90eF90cnlfYXNzaWduKHR4LCB0eGdfaG93KSkgIT0gMCkgewogCQlkbXVfdHhfdW5hc3Np Z24odHgpOwogCkBAIC0xMzIzLDcgKzEzNjIsNyBAQAogCQkgKiBzcGFjZS4KIAkJICovCiAJCW11 dGV4X2VudGVyKCZkcC0+ZHBfbG9jayk7Ci0JCXdoaWxlIChkcC0+ZHBfZGlydHlfdG90YWwgPj0g emZzX2RpcnR5X2RhdGFfbWF4KQorCQl3aGlsZSAoZHAtPmRwX2RpcnR5X3RvdGFsID49IHpmc19k aXJ0eV9kYXRhX21heF9pbnRlcm5hbCkKIAkJCWN2X3dhaXQoJmRwLT5kcF9zcGFjZWF2YWlsX2N2 LCAmZHAtPmRwX2xvY2spOwogCQl1aW50NjRfdCBkaXJ0eSA9IGRwLT5kcF9kaXJ0eV90b3RhbDsK IAkJbXV0ZXhfZXhpdCgmZHAtPmRwX2xvY2spOwpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVu c29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9kc2xfcG9vbC5jCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9j ZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZHNsX3Bvb2wuYwkocmV2 aXNpb24gMjg4NjAwKQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9u L2ZzL3pmcy9kc2xfcG9vbC5jCSh3b3JraW5nIGNvcHkpCkBAIC05OCw4ICs5OCwxMSBAQAogLyoK ICAqIHpmc19kaXJ0eV9kYXRhX21heCB3aWxsIGJlIHNldCB0byB6ZnNfZGlydHlfZGF0YV9tYXhf cGVyY2VudCUgb2YgYWxsIG1lbW9yeSwKICAqIGNhcHBlZCBhdCB6ZnNfZGlydHlfZGF0YV9tYXhf bWF4LiAgSXQgY2FuIGFsc28gYmUgb3ZlcnJpZGRlbiBpbiAvZXRjL3N5c3RlbS4KKyAqIFdlIGFs c28gZHluYW1pY2FsbHkgdHVuZSBkdXJpbmcgbG93IG1lbW9yeSwgaG9ub3JpbmcgdGhlIHN5c2N0 bCBzZXQsIHNvCisgKiBpbnRlcm5hbCBjb21wYXJpc29ucyBhcmUgYWdhaW5zdCB6ZnNfZGlydHlf ZGF0YV9tYXhfaW50ZXJuYWwuCiAgKi8KIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heDsKK3Vp bnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbDsKIHVpbnQ2NF90IHpmc19kaXJ0eV9k YXRhX21heF9tYXggPSA0VUxMICogMTAyNCAqIDEwMjQgKiAxMDI0OwogaW50IHpmc19kaXJ0eV9k YXRhX21heF9wZXJjZW50ID0gMTA7CiAKQEAgLTU1Nyw3ICs1NjAsNyBAQAogCSAqIE5vdGU6IHdl IHNpZ25hbCBldmVuIHdoZW4gaW5jcmVhc2luZyBkcF9kaXJ0eV90b3RhbC4KIAkgKiBUaGlzIGVu c3VyZXMgZm9yd2FyZCBwcm9ncmVzcyAtLSBlYWNoIHRocmVhZCB3YWtlcyB0aGUgbmV4dCB3YWl0 ZXIuCiAJICovCi0JaWYgKGRwLT5kcF9kaXJ0eV90b3RhbCA8PSB6ZnNfZGlydHlfZGF0YV9tYXgp CisJaWYgKGRwLT5kcF9kaXJ0eV90b3RhbCA8PSB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwp CiAJCWN2X3NpZ25hbCgmZHAtPmRwX3NwYWNlYXZhaWxfY3YpOwogfQogCkBAIC03MzYsNyArNzM5 LDcgQEAKIGRzbF9wb29sX25lZWRfZGlydHlfZGVsYXkoZHNsX3Bvb2xfdCAqZHApCiB7CiAJdWlu dDY0X3QgZGVsYXlfbWluX2J5dGVzID0KLQkgICAgemZzX2RpcnR5X2RhdGFfbWF4ICogemZzX2Rl bGF5X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOworCSAgICB6ZnNfZGlydHlfZGF0YV9tYXhfaW50 ZXJuYWwgKiB6ZnNfZGVsYXlfbWluX2RpcnR5X3BlcmNlbnQgLyAxMDA7CiAJYm9vbGVhbl90IHJ2 OwogCiAJbXV0ZXhfZW50ZXIoJmRwLT5kcF9sb2NrKTsKSW5kZXg6IHN5cy9jZGRsL2NvbnRyaWIv b3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvc3lzL2RzbF9wb29sLmgKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9zeXMvZHNs X3Bvb2wuaAkocmV2aXNpb24gMjg4NjAwKQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJp cy91dHMvY29tbW9uL2ZzL3pmcy9zeXMvZHNsX3Bvb2wuaAkod29ya2luZyBjb3B5KQpAQCAtNTAs NiArNTAsNyBAQAogc3RydWN0IGRzbF9zY2FuOwogCiBleHRlcm4gdWludDY0X3QgemZzX2RpcnR5 X2RhdGFfbWF4OworZXh0ZXJuIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbDsK IGV4dGVybiB1aW50NjRfdCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4OwogZXh0ZXJuIHVpbnQ2NF90 IHpmc19kaXJ0eV9kYXRhX3N5bmM7CiBleHRlcm4gaW50IHpmc19kaXJ0eV9kYXRhX21heF9wZXJj ZW50OwpJbmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pm cy96aW8uYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9j b21tb24vZnMvemZzL3ppby5jCShyZXZpc2lvbiAyODg2MDApCisrKyBzeXMvY2RkbC9jb250cmli L29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3ppby5jCSh3b3JraW5nIGNvcHkpCkBAIC00 MywxMCArNDMsMTMgQEAKIAogU1lTQ1RMX0RFQ0woX3Zmc196ZnMpOwogU1lTQ1RMX05PREUoX3Zm c196ZnMsIE9JRF9BVVRPLCB6aW8sIENUTEZMQUdfUlcsIDAsICJaRlMgWklPIik7CisvKiBLRCAy MDE1LTA3LTE1IENoYW5nZSBjbGFzcyB0byAiaW50IiBmcm9tICJzdGF0aWMgaW50IiBhcyB3ZSBy ZWZlcmVuY2UgCisgKiB0aGlzIGFzIGFuIGV4dGVybiBlbHNld2hlcmUKKyAqLwogI2lmIGRlZmlu ZWQoX19hbWQ2NF9fKQotc3RhdGljIGludCB6aW9fdXNlX3VtYSA9IDE7CitpbnQgemlvX3VzZV91 bWEgPSAxOwogI2Vsc2UKLXN0YXRpYyBpbnQgemlvX3VzZV91bWEgPSAwOworaW50IHppb191c2Vf dW1hID0gMDsKICNlbmRpZgogVFVOQUJMRV9JTlQoInZmcy56ZnMuemlvLnVzZV91bWEiLCAmemlv X3VzZV91bWEpOwogU1lTQ1RMX0lOVChfdmZzX3pmc196aW8sIE9JRF9BVVRPLCB1c2VfdW1hLCBD VExGTEFHX1JEVFVOLCAmemlvX3VzZV91bWEsIDAsCg== 161943 2015-10-12 12:40:33 +0000 2015-12-10 15:48:51 +0000 Patch for 10.2-STABLE r289078 including pagedaemon wakeup code patch-10.2-STABLE-2015-10-12-candidate text/plain 15277 karl SW5kZXg6IHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvYXJj LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9u L2ZzL3pmcy9hcmMuYwkocmV2aXNpb24gMjg5MDc4KQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVu c29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMjE2LDYg KzIxNiwxNSBAQAogZXh0ZXJuIGJvb2xlYW5fdCB6ZnNfcHJlZmV0Y2hfZGlzYWJsZTsKIAogLyoK KyAqIEtEIDIwMTUtMDItMTAKKyAqIFdlIGhhdmUgdG8gYmUgYWJsZSB0byB0ZXN0IGZvciBVSU8g dXNlIGluc2lkZSB0aGUgYXJjIGFsbG9jYXRvci4KKyAqIE5PVEU6IERPIE5PVCBNT0RJRlkgSEVS RSEKKyAqLworZXh0ZXJuIGludCB6aW9fdXNlX3VtYTsKK2V4dGVybiBpbnQgemZzX2R5bmFtaWNf d3JpdGVfYnVmZmVyOworCisKKy8qCiAgKiBUaGUgYXJjIGhhcyBmaWxsZWQgYXZhaWxhYmxlIG1l bW9yeSBhbmQgaGFzIG5vdyB3YXJtZWQgdXAuCiAgKi8KIHN0YXRpYyBib29sZWFuX3QgYXJjX3dh cm07CkBAIC0yMzMsNyArMjQyLDE1IEBACiBpbnQgemZzX2Rpc2FibGVfZHVwX2V2aWN0aW9uID0g MDsKIHVpbnQ2NF90IHpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUgPSA4ICogMTAyNDsgLyogOEtC ICovCiB1X2ludCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gMDsKK3VfaW50IHpmc19hcmNfd2FrZXVw X3BhZ2VyID0gMDsKK3VfaW50IHpmc19hcmNfd2FrZXVwX2RlbGF5ID0gNTAwOwogCisjZGVmaW5l CVdBS0VfUEFHRVIKKyNpZmRlZglXQUtFX1BBR0VSCisjZGVmaW5lCVdBS0VfUEFHRVJfQ09OU1RB TlQJMTAgLyA5CQkvKiBQYWdlciB3YWtldXAgdGhyZXNob2xkICovCitzdGF0aWMJaW50CWFyY19p bml0X2RvbmUgPSAwOwkJLyogV2Uga25vdyBhcmNfd2FybSBpcyB2YWxpZCAqLworI2VuZGlmCS8q IFdBS0VfUEFHRVIgKi8KKwogc3RhdGljIGludCBzeXNjdGxfdmZzX3pmc19hcmNfZnJlZV90YXJn ZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CiBzdGF0aWMgaW50IHN5c2N0bF92ZnNfemZzX2FyY19t ZXRhX2xpbWl0KFNZU0NUTF9IQU5ETEVSX0FSR1MpOwogCkBAIC0yNDIsNyArMjU5LDEwIEBACiBh cmNfZnJlZV90YXJnZXRfaW5pdCh2b2lkICp1bnVzZWQgX191bnVzZWQpCiB7CiAKLQl6ZnNfYXJj X2ZyZWVfdGFyZ2V0ID0gdm1fcGFnZW91dF93YWtldXBfdGhyZXNoOworCXpmc19hcmNfZnJlZV90 YXJnZXQgPSB2bV9wYWdlb3V0X3dha2V1cF90aHJlc2ggKyAoKGNudC52X2ZyZWVfdGFyZ2V0IC0g dm1fcGFnZW91dF93YWtldXBfdGhyZXNoKSAvIDIpOworI2lmZGVmCVdBS0VfUEFHRVIKKwl6ZnNf YXJjX3dha2V1cF9wYWdlciA9IHpmc19hcmNfZnJlZV90YXJnZXQgKiBXQUtFX1BBR0VSX0NPTlNU QU5UOworI2VuZGlmCS8qIFdBS0VfUEFHRVIgKi8KIH0KIFNZU0lOSVQoYXJjX2ZyZWVfdGFyZ2V0 X2luaXQsIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX0FOWSwKICAgICBhcmNfZnJlZV90 YXJnZXRfaW5pdCwgTlVMTCk7CkBAIC0yNjQsNyArMjg0LDE1IEBACiBTWVNDVExfSU5UKF92ZnNf emZzLCBPSURfQVVUTywgYXJjX3Nocmlua19zaGlmdCwgQ1RMRkxBR19SVywKICAgICAmYXJjX3No cmlua19zaGlmdCwgMCwKICAgICAibG9nMihmcmFjdGlvbiBvZiBhcmMgdG8gcmVjbGFpbSkiKTsK LQorU1lTQ1RMX0lOVChfdmZzX3pmcywgT0lEX0FVVE8sIGR5bmFtaWNfd3JpdGVfYnVmZmVyLCBD VExGTEFHX1JXVFVOLAorICAgICZ6ZnNfZHluYW1pY193cml0ZV9idWZmZXIsIDAsCisgICAgIkR5 bmFtaWNhbGx5IHJlc3RyaWN0IGRpcnR5IGRhdGEgd2hlbiBtZW1vcnkgaXMgbG93Iik7CisjaWZk ZWYJV0FLRV9QQUdFUgorU1lTQ1RMX1VJTlQoX3Zmc196ZnMsIE9JRF9BVVRPLCBhcmNfd2FrZXVw X3BhZ2VyLCBDVExGTEFHX1JXVFVOLCAKKwkmemZzX2FyY193YWtldXBfcGFnZXIsIDAsICJXYWtl IFZNIGJlbG93IHRoaXMgbnVtYmVyIG9mIHBhZ2VzIik7CitTWVNDVExfVUlOVChfdmZzX3pmcywg T0lEX0FVVE8sIGFyY193YWtldXBfZGVsYXksIENUTEZMQUdfUldUVU4sIAorCSZ6ZnNfYXJjX3dh a2V1cF9kZWxheSwgMCwgIk1heSB3YWtlIHVwIFZNIG9uY2UgdGhpcyBudW1iZXIgb2YgTVMiKTsK KyNlbmRpZgkvKiBXQUtFX1BBR0VSICovCiAvKgogICogV2UgZG9uJ3QgaGF2ZSBhIHR1bmFibGUg Zm9yIGFyY19mcmVlX3RhcmdldCBkdWUgdG8gdGhlIGRlcGVuZGVuY3kgb24KICAqIHBhZ2VkYWVt b24gaW5pdGlhbGlzYXRpb24uCkBAIC0yOTEsNiArMzE5LDkgQEAKIAkJcmV0dXJuIChFSU5WQUwp OwogCiAJemZzX2FyY19mcmVlX3RhcmdldCA9IHZhbDsKKyNpZmRlZglXQUtFX1BBR0VSCisJemZz X2FyY193YWtldXBfcGFnZXIgPSB6ZnNfYXJjX2ZyZWVfdGFyZ2V0ICogV0FLRV9QQUdFUl9DT05T VEFOVDsKKyNlbmRpZgkvKiBXQUtFX1BBR0VSICovCiAKIAlyZXR1cm4gKDApOwogfQpAQCAtMzM2 Nyw2ICszMzk4LDExIEBACiBpbnQ2NF90IGFyY19zd2FwZnNfcmVzZXJ2ZSA9IDY0OwogCiAvKgor ICogRGVjbGFyZSBmaWxlLWxvY2FsIHN0YXRpYyBmb3IgZXZlbnQgcHJvY2Vzc29yIGJ5cGFzcwor ICovCitzdGF0aWMgdW5zaWduZWQgaW50IGFyY19ub193YWtlX2V2ZW50ID0gMDsKKworLyoKICAq IFJldHVybiB0aGUgYW1vdW50IG9mIG1lbW9yeSB0aGF0IGNhbiBiZSBjb25zdW1lZCBiZWZvcmUg cmVjbGFpbSB3aWxsIGJlCiAgKiBuZWVkZWQuICBQb3NpdGl2ZSBpZiB0aGVyZSBpcyBzdWZmaWNp ZW50IGZyZWUgbWVtb3J5LCBuZWdhdGl2ZSBpbmRpY2F0ZXMKICAqIHRoZSBhbW91bnQgb2YgbWVt b3J5IHRoYXQgbmVlZHMgdG8gYmUgZnJlZWQgdXAuCkBAIC0zMzc5LDYgKzM0MTUsMTAgQEAKIAlm cmVlX21lbW9yeV9yZWFzb25fdCByID0gRk1SX1VOS05PV047CiAKICNpZmRlZiBfS0VSTkVMCisj aWZkZWYJV0FLRV9QQUdFUgorCXNiaW50aW1lX3Qgbm93OworCXN0YXRpYyBzYmludGltZV90IGxh c3RfcGFnZWRhZW1vbl93YWtlID0gMDsKKyNlbmRpZgkvKiBXQUtFX1BBR0VSICovCiAJaWYgKG5l ZWRmcmVlID4gMCkgewogCQluID0gUEFHRVNJWkUgKiAoLW5lZWRmcmVlKTsKIAkJaWYgKG4gPCBs b3dlc3QpIHsKQEAgLTMzOTcsNiArMzQzNywyNiBAQAogCQlyID0gRk1SX0xPVFNGUkVFOwogCX0K IAorI2lmZGVmCVdBS0VfUEFHRVIKKy8qCisgKiBJZiBtZW1vcnkgaXMgbGVzcyB0aGFuIHRoZSBB UkMgd2FrZXVwIHRocmVzaG9sZCBhbmQgdGltZSBoYXMgZXhwaXJlZCBzaW5jZQorICogdGhlIGxh c3QgdGltZSB3ZSB3b2tlIHRoZSBwYWdlci4uLiBEbyBub3QgZXhlY3V0ZSB1bnRpbCB0aGUgQVJD IHdhcm1zIHVwLgorICovCisJaWYgKChhcmNfaW5pdF9kb25lKSAmJgorCQkoKChpbnQ2NF90KSBm cmVlbWVtIC0gemZzX2FyY193YWtldXBfcGFnZXIpIDwgMCkgJiYKKwkJKGFyY193YXJtID09IEJf VFJVRSkKKwkpIHsKKwkJbm93ID0gZ2V0c2JpbnVwdGltZSgpOworCQlpZiAoKG5vdyAtIGxhc3Rf cGFnZWRhZW1vbl93YWtlKSAvIFNCVF8xTVMgPiB6ZnNfYXJjX3dha2V1cF9kZWxheSkgeworCQkJ bGFzdF9wYWdlZGFlbW9uX3dha2UgPSBub3c7CisJCQlhcmNfbm9fd2FrZV9ldmVudCsrOwkvKiBT ZXQgYnlwYXNzIGZsYWcgZm9yIEFSQyAqLworCQkJRFRSQUNFX1BST0JFKGFyY19fd2FrZV9wYWdl ZGFlbW9uKTsKKwkJCXBhZ2VkYWVtb25fd2FrZXVwKCk7CS8qIFdha2UgdGhlIHBhZ2VyICovCisJ CX0KKwl9CisKKyNlbmRpZgkvKiBXQUtFX1BBR0VSICovCisKICNpZmRlZiBzdW4KIAkvKgogCSAq IGNoZWNrIHRoYXQgd2UncmUgb3V0IG9mIHJhbmdlIG9mIHRoZSBwYWdlb3V0IHNjYW5uZXIuICBJ dCBzdGFydHMgdG8KQEAgLTM1MDUsNiArMzU2NSw3IEBACiAJbGFzdF9mcmVlX21lbW9yeSA9IGxv d2VzdDsKIAlsYXN0X2ZyZWVfcmVhc29uID0gcjsKIAlEVFJBQ0VfUFJPQkUyKGFyY19fYXZhaWxh YmxlX21lbW9yeSwgaW50NjRfdCwgbG93ZXN0LCBpbnQsIHIpOworCiAJcmV0dXJuIChsb3dlc3Qp OwogfQogCkBAIC0zNTI0LDYgKzM1ODUsNDMgQEAKIGV4dGVybiBrbWVtX2NhY2hlX3QJKnppb19k YXRhX2J1Zl9jYWNoZVtdOwogZXh0ZXJuIGttZW1fY2FjaGVfdAkqcmFuZ2Vfc2VnX2NhY2hlOwog CisvKgorICogVXNlZCBieSBhcmNfa21lbV9yZWFwX25vdygpIGFuZCBjb25zaWRlcl9yZWFwaW5n X2FyY19jYWNoZXMoKQorICogdG8gbGltaXQgdGhlIHRpbWUgc3BlbnQgcmVhcGluZy4KKyAqCisg KiBUaGUgYXJjX3JlYXBpbmdfaW5fcHJvZ3Jlc3MgaXMgYSAoc29tZXdoYXQgcmFjeSkgbGVmdCBv dmVyIGZyb20gYQorICogcHJldmlvdXMgdmVyc2lvbiBvZiB0aGlzIGNvZGUgd2hpY2ggY291bGQg dHJpZ2dlciBtdWx0aXBsZSBBUkMgY2FjaGUKKyAqIHJlYXBpbmdzIGluIHBhcmFsbGVsIHdoaWNo IHNob3VsZCBiZSBhdm9pZGVkIHRvIHJlZHVjZSBsb2NrCisgKiBjb250ZW50aW9uLiBJdCdzIGhh c24ndCBiZWVuIHJlbW92ZWQgeWV0IHRvIGVuY291cmFnZSBmdXJ0aGVyCisgKiBleHBlcmltZW50 aW5nLgorICovCitzdGF0aWMgdW5zaWduZWQgaW50IGFyY19yZWFwaW5nX2luX3Byb2dyZXNzID0g MDsKK3N0YXRpYyB1bnNpZ25lZCBpbnQgYXJjX3BhZ2VkYWVtb25faWdub3JlID0gMDsKK3N0YXRp YyBzYmludGltZV90IGxhc3RfcmVhcGluZyA9IDA7CisKK3N0YXRpYyB2b2lkIF9fbm9pbmxpbmUK K3JlYXBfYXJjX2NhY2hlcyh2b2lkKQoreworCXNpemVfdCAgICAgICAgICBpOworCWttZW1fY2Fj aGVfdCAgICAgICAgICAgICpwcmV2X2NhY2hlID0gTlVMTDsKKwlrbWVtX2NhY2hlX3QgICAgICAg ICAgICAqcHJldl9kYXRhX2NhY2hlID0gTlVMTDsKKworCWZvciAoaSA9IDA7IGkgPCBTUEFfTUFY QkxPQ0tTSVpFID4+IFNQQV9NSU5CTE9DS1NISUZUOyBpKyspIHsKKwkJaWYgKHppb19idWZfY2Fj aGVbaV0gIT0gcHJldl9jYWNoZSkgeworCQkJcHJldl9jYWNoZSA9IHppb19idWZfY2FjaGVbaV07 CisJCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19idWZfY2FjaGVbaV0pOworCQl9CisJCWlmICh6 aW9fZGF0YV9idWZfY2FjaGVbaV0gIT0gcHJldl9kYXRhX2NhY2hlKSB7CisJCQlwcmV2X2RhdGFf Y2FjaGUgPSB6aW9fZGF0YV9idWZfY2FjaGVbaV07CisJCQlrbWVtX2NhY2hlX3JlYXBfbm93KHpp b19kYXRhX2J1Zl9jYWNoZVtpXSk7CisJCX0KKwl9CisJa21lbV9jYWNoZV9yZWFwX25vdyhidWZf Y2FjaGUpOworCWttZW1fY2FjaGVfcmVhcF9ub3coaGRyX2Z1bGxfY2FjaGUpOworCWttZW1fY2Fj aGVfcmVhcF9ub3coaGRyX2wyb25seV9jYWNoZSk7CisJa21lbV9jYWNoZV9yZWFwX25vdyhyYW5n ZV9zZWdfY2FjaGUpOworfQorCiBzdGF0aWMgX19ub2lubGluZSB2b2lkCiBhcmNfa21lbV9yZWFw X25vdyh2b2lkKQogewpAQCAtMzUzMiw2ICszNjMwLDggQEAKIAlrbWVtX2NhY2hlX3QJCSpwcmV2 X2RhdGFfY2FjaGUgPSBOVUxMOwogCiAJRFRSQUNFX1BST0JFKGFyY19fa21lbV9yZWFwX3N0YXJ0 KTsKKwlhcmNfcmVhcGluZ19pbl9wcm9ncmVzcysrOworCiAjaWZkZWYgX0tFUk5FTAogCWlmIChh cmNfbWV0YV91c2VkID49IGFyY19tZXRhX2xpbWl0KSB7CiAJCS8qCkBAIC0zNTQ4LDIwICszNjQ4 LDcgQEAKICNlbmRpZgogI2VuZGlmCiAKLQlmb3IgKGkgPSAwOyBpIDwgU1BBX01BWEJMT0NLU0la RSA+PiBTUEFfTUlOQkxPQ0tTSElGVDsgaSsrKSB7Ci0JCWlmICh6aW9fYnVmX2NhY2hlW2ldICE9 IHByZXZfY2FjaGUpIHsKLQkJCXByZXZfY2FjaGUgPSB6aW9fYnVmX2NhY2hlW2ldOwotCQkJa21l bV9jYWNoZV9yZWFwX25vdyh6aW9fYnVmX2NhY2hlW2ldKTsKLQkJfQotCQlpZiAoemlvX2RhdGFf YnVmX2NhY2hlW2ldICE9IHByZXZfZGF0YV9jYWNoZSkgewotCQkJcHJldl9kYXRhX2NhY2hlID0g emlvX2RhdGFfYnVmX2NhY2hlW2ldOwotCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6aW9fZGF0YV9i dWZfY2FjaGVbaV0pOwotCQl9Ci0JfQotCWttZW1fY2FjaGVfcmVhcF9ub3coYnVmX2NhY2hlKTsK LQlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9mdWxsX2NhY2hlKTsKLQlrbWVtX2NhY2hlX3JlYXBf bm93KGhkcl9sMm9ubHlfY2FjaGUpOwotCWttZW1fY2FjaGVfcmVhcF9ub3cocmFuZ2Vfc2VnX2Nh Y2hlKTsKKwlyZWFwX2FyY19jYWNoZXMoKTsKIAogI2lmZGVmIHN1bgogCWlmICh6aW9fYXJlbmEg IT0gTlVMTCkgewpAQCAtMzU3MiwxMCArMzY1OSw1MSBAQAogCQl2bWVtX3FjYWNoZV9yZWFwKHpp b19hcmVuYSk7CiAJfQogI2VuZGlmCisjaWZkZWYgX0tFUk5FTAorCWxhc3RfcmVhcGluZyA9IGdl dHNiaW51cHRpbWUoKTsKKyNlbmRpZgorCWFyY19yZWFwaW5nX2luX3Byb2dyZXNzID0gMDsKIAlE VFJBQ0VfUFJPQkUoYXJjX19rbWVtX3JlYXBfZW5kKTsKIH0KIAorCiAvKgorICogRGVjbGFyZWQg d3JpdGFibGUgdG8gYWxsb3cgcmVzZXR0aW5nIGl0LgorICogWFhYOiBTaG91bGQgcHJvYmFibHkg YmUgYSB1aW50NjQgYW5kIGludGVncmF0ZWQgd2l0aCBrc3RhdC4KKyAqLworc3RhdGljIHVuc2ln bmVkIGludCBhcmNfY2FjaGVfcmVhcGluZ3Nfc2tpcHBlZCA9IDA7CitTWVNDVExfVUlOVChfdmZz X3pmcywgT0lEX0FVVE8sIGFyY19jYWNoZV9yZWFwaW5nc19za2lwcGVkLCBDVExGTEFHX1JXLAor ICAgICZhcmNfY2FjaGVfcmVhcGluZ3Nfc2tpcHBlZCwgMCwgIk51bWJlciBvZiB0aW1lcyB0aGUg QVJDIGNhY2hlcyBoYXZlIG5vdCBiZWVuIHJlYXBlZCBkdWUgdG8gdGhlIHJlYXAgZGVsYXkiKTsK Kworc3RhdGljIHVuc2lnbmVkIGludCBtaW5fYXJjX3JlYXBfZGVsYXkgPSAyMDA7CitTWVNDVExf VUlOVChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY19yZWFwX2RlbGF5X21pbiwgQ1RMRkxBR19SVywK KyAgICAmbWluX2FyY19yZWFwX2RlbGF5LCAyMDAsICJNaW5pbXVtIGRlbGF5IGJldHdlZW4gQVJD IGNhY2hlIHJlYXBpbmdzIChtaWxsaXNlY29uZHMpIik7CisKK3N0YXRpYyB2b2lkIF9fbm9pbmxp bmUKK2NvbnNpZGVyX3JlYXBpbmdfYXJjX2NhY2hlcyh2b2lkKQoreworI2lmZGVmIF9LRVJORUwK KwlzYmludGltZV90IG5vdzsKKworCWlmIChhcmNfcmVhcGluZ19pbl9wcm9ncmVzcykKKwl7CisJ CS8qIEFscmVhZHkgcmVhcGluZyBpbiBhbm90aGVyIHRocmVhZC4gKi8KKwkJYXJjX2NhY2hlX3Jl YXBpbmdzX3NraXBwZWQrKzsKKwkJcmV0dXJuOworCX0KKworCW5vdyA9IGdldHNiaW51cHRpbWUo KTsKKwlpZiAoKG5vdyAtIGxhc3RfcmVhcGluZykgLyBTQlRfMU1TIDwgbWluX2FyY19yZWFwX2Rl bGF5KQorCXsKKwkJLyogVG9vIHNvb24gdG8gcmVhcCBhZ2Fpbi4gKi8KKwkJYXJjX2NhY2hlX3Jl YXBpbmdzX3NraXBwZWQrKzsKKwkJcmV0dXJuOworCX0KKyNlbmRpZgorCWFyY19rbWVtX3JlYXBf bm93KCk7Cit9CisKKy8qCiAgKiBUaHJlYWRzIGNhbiBibG9jayBpbiBhcmNfZ2V0X2RhdGFfYnVm KCkgd2FpdGluZyBmb3IgdGhpcyB0aHJlYWQgdG8gZXZpY3QKICAqIGVub3VnaCBkYXRhIGFuZCBz aWduYWwgdGhlbSB0byBwcm9jZWVkLiBXaGVuIHRoaXMgaGFwcGVucywgdGhlIHRocmVhZHMgaW4K ICAqIGFyY19nZXRfZGF0YV9idWYoKSBhcmUgc2xlZXBpbmcgd2hpbGUgaG9sZGluZyB0aGUgaGFz aCBsb2NrIGZvciB0aGVpcgpAQCAtMzYxNyw4ICszNzQ1LDYgQEAKIAkJCSAqLwogCQkJZ3Jvd3Rp bWUgPSBkZGlfZ2V0X2xib2x0KCkgKyAoYXJjX2dyb3dfcmV0cnkgKiBoeik7CiAKLQkJCWFyY19r bWVtX3JlYXBfbm93KCk7Ci0KIAkJCS8qCiAJCQkgKiBJZiB3ZSBhcmUgc3RpbGwgbG93IG9uIG1l bW9yeSwgc2hyaW5rIHRoZSBBUkMKIAkJCSAqIHNvIHRoYXQgd2UgaGF2ZSBhcmNfc2hyaW5rX21p biBmcmVlIHNwYWNlLgpAQCAtMzY5Miw2ICszODE4LDEyIEBACiAJd2hpbGUgKCFhcmNfdXNlcl9l dmljdHNfdGhyZWFkX2V4aXQpIHsKIAkJbXV0ZXhfZXhpdCgmYXJjX3VzZXJfZXZpY3RzX2xvY2sp OwogCisJCS8qCisJCSAqIENvbnNpZGVyIHJlYXBpbmcgdGhlIEFSQyBjYWNoZXMgYXQgbGVhc3Qg b25jZSBwZXIKKwkJICogc2Vjb25kLCBidXQgbW9yZSBvZnRlbiB3aGVuIHNpZ25hbGxlZCB1bmRl ciBwcmVzc3VyZS4KKwkJICovCisJCWNvbnNpZGVyX3JlYXBpbmdfYXJjX2NhY2hlcygpOworCiAJ CWFyY19kb191c2VyX2V2aWN0cygpOwogCiAJCS8qCkBAIC01MjQzLDcgKzUzNzUsMTAgQEAKIHN0 YXRpYyB2b2lkCiBhcmNfbG93bWVtKHZvaWQgKmFyZyBfX3VudXNlZCwgaW50IGhvd3RvIF9fdW51 c2VkKQogewotCisJaWYgKGFyY19ub193YWtlX2V2ZW50KSB7CS8qIERvbid0IGRvIGl0IGlmIHdl IHdva2UgdGhlIHBhZ2VyICovCisJCWFyY19ub193YWtlX2V2ZW50ID0gMDsJLyogSnVzdCBjbGVh ciB0aGUgZmxhZyAqLworCQlyZXR1cm47CisJfQogCW11dGV4X2VudGVyKCZhcmNfcmVjbGFpbV9s b2NrKTsKIAkvKiBYWFg6IE1lbW9yeSBkZWZpY2l0IHNob3VsZCBiZSBwYXNzZWQgYXMgYXJndW1l bnQuICovCiAJbmVlZGZyZWUgPSBidG9jKGFyY19jID4+IGFyY19zaHJpbmtfc2hpZnQpOwpAQCAt NTQ5MSw2ICs1NjI2LDkgQEAKIAkJcHJpbnRmKCIgICAgICAgICAgICAgaW4gL2Jvb3QvbG9hZGVy LmNvbmYuXG4iKTsKIAl9CiAjZW5kaWYKKyNpZmRlZglXQUtFX1BBR0VSCisJYXJjX2luaXRfZG9u ZSsrOwkvKiBGb3IgYW55b25lIHdobyB3YW50cyB0byBrbm93ICovCisjZW5kaWYJLyogV0FLRV9Q QUdFUiAqLwogfQogCiB2b2lkCkluZGV4OiBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0 cy9jb21tb24vZnMvemZzL2RtdV90eC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9jZGRsL2NvbnRyaWIv b3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZG11X3R4LmMJKHJldmlzaW9uIDI4OTA3OCkK KysrIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvZG11X3R4 LmMJKHdvcmtpbmcgY29weSkKQEAgLTQyLDYgKzQyLDggQEAKIHR5cGVkZWYgdm9pZCAoKmRtdV90 eF9ob2xkX2Z1bmNfdCkoZG11X3R4X3QgKnR4LCBzdHJ1Y3QgZG5vZGUgKmRuLAogICAgIHVpbnQ2 NF90IGFyZzEsIHVpbnQ2NF90IGFyZzIpOwogCitleHRlcm4JaW50CXppb191c2VfdW1hOwkvKiBO ZWVkcyB0byBiZSB2aXNpYmxlOyBETyBOT1QgTU9ESUZZISAqLworaW50CXpmc19keW5hbWljX3dy aXRlX2J1ZmZlciA9IDE7CS8qIER5bmFtaWNhbGx5IHR1bmUgd3JpdGVzICovCiAKIGRtdV90eF90 ICoKIGRtdV90eF9jcmVhdGVfZGQoZHNsX2Rpcl90ICpkZCkKQEAgLTEwNjAsNyArMTA2Miw3IEBA CiB7CiAJZHNsX3Bvb2xfdCAqZHAgPSB0eC0+dHhfcG9vbDsKIAl1aW50NjRfdCBkZWxheV9taW5f Ynl0ZXMgPQotCSAgICB6ZnNfZGlydHlfZGF0YV9tYXggKiB6ZnNfZGVsYXlfbWluX2RpcnR5X3Bl cmNlbnQgLyAxMDA7CisJICAgIHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCAqIHpmc19kZWxh eV9taW5fZGlydHlfcGVyY2VudCAvIDEwMDsKIAlocnRpbWVfdCB3YWtldXAsIG1pbl90eF90aW1l LCBub3c7CiAKIAlpZiAoZGlydHkgPD0gZGVsYXlfbWluX2J5dGVzKQpAQCAtMTA3MiwxMSArMTA3 NCwxMSBAQAogCSAqIGhhdmUgdG8gaGFuZGxlIHRoZSBjYXNlIG9mIGl0IGJlaW5nID49IHRoZSBt YXgsIHdoaWNoIGNvdWxkCiAJICogY2F1c2UgYSBkaXZpZGUtYnktemVybyBpZiBpdCdzID09IHRo ZSBtYXguCiAJICovCi0JQVNTRVJUM1UoZGlydHksIDwsIHpmc19kaXJ0eV9kYXRhX21heCk7CisJ QVNTRVJUM1UoZGlydHksIDwsIHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCk7CiAKIAlub3cg PSBnZXRocnRpbWUoKTsKIAltaW5fdHhfdGltZSA9IHpmc19kZWxheV9zY2FsZSAqCi0JICAgIChk aXJ0eSAtIGRlbGF5X21pbl9ieXRlcykgLyAoemZzX2RpcnR5X2RhdGFfbWF4IC0gZGlydHkpOwor CSAgICAoZGlydHkgLSBkZWxheV9taW5fYnl0ZXMpIC8gKHpmc19kaXJ0eV9kYXRhX21heF9pbnRl cm5hbCAtIGRpcnR5KTsKIAlpZiAobm93ID4gdHgtPnR4X3N0YXJ0ICsgbWluX3R4X3RpbWUpCiAJ CXJldHVybjsKIApAQCAtMTI4MSw2ICsxMjgzLDcgQEAKIGRtdV90eF9hc3NpZ24oZG11X3R4X3Qg KnR4LCB0eGdfaG93X3QgdHhnX2hvdykKIHsKIAlpbnQgZXJyOworCXN0YXRpYwl1aW50NjRfdAls YXN0X21heDsKIAogCUFTU0VSVCh0eC0+dHhfdHhnID09IDApOwogCUFTU0VSVCh0eGdfaG93ID09 IFRYR19XQUlUIHx8IHR4Z19ob3cgPT0gVFhHX05PV0FJVCB8fApAQCAtMTI5Myw2ICsxMjk2LDQy IEBACiAJaWYgKHR4Z19ob3cgPT0gVFhHX1dBSVRFRCkKIAkJdHgtPnR4X3dhaXRlZCA9IEJfVFJV RTsKIAorI2lmZGVmIF9LRVJORUwKKwkvKgorCSAqIEtEIDIwMTQtMDktMjIKKwkgKiBJZiBVTUEg aXMgZW5hYmxlZCBpdCBjYW4gb25seSByZXR1cm4gYSBwcmV2aW91c2x5LXVzZWQgYmxvY2sKKwkg KiBvZiBpZGVudGljYWwgc2l6ZSB0byB3aGF0IGl0IGhhZCBvdXQgYmVmb3JlLiAgSWYgaXQncyBu b3QgdGhlCisJICogc2FtZSBzaXplIGl0IHdpbGwgYWxsb2NhdGUgYSBuZXcgb25lLiAgVGhpcyBp cyBhIHByb2JsZW0gYmVjYXVzZQorCSAqIGRpcnR5X2RhdGFfbWF4IGlzIHRoZSB0b3RhbCBkaXJ0 eSB3cml0ZSBkYXRhIGFsbG93ZWQgb3V0IGF0IGFueQorCSAqIGdpdmVuIHRpbWUsIGJ1dCB3aXRo IFVNQSBvbiB0aGF0IGNhbiBtdWx0aXBseSBieSB0aGUgbnVtYmVyIG9mCisJICogZGlmZmVyZW50 IGJsb2NrIHNpemVzICghISkgcmVxdWVzdGVkIGluIHRlcm1zIG9mIGZyZWUgUkFNIHRoYXQKKwkg KiBpcyBsZWZ0IGFsbG9jYXRlZCBidXQgdW51c2VkLiAgRm9yIHRoaXMgcmVhc29uIG5ldmVyIGFs bG93CisJICogZGlydHlfZGF0YV9tYXggdG8gZXhjZWVkIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4g dGhlIHBhZ2luZworCSAqIHRocmVzaG9sZCBhbmQgdGhlIGN1cnJlbnQgZnJlZSBtZW1vcnksIHdp dGggYSBtaW5pbXVtIG9mIDI1Nk1CLgorCSAqIFRoaXMgdGhyb3R0bGVzICJidXJzdCIgYWxsb2Nh dGlvbnMgYW5kIHByZXZlbnRzIHRoZSBzeXN0ZW0gZnJvbQorCSAqIGNob2tpbmcgZHVyaW5nIHRp bWVzIG9mIGhpZ2ggd3JpdGUgSS9PIGRlbWFuZC4KKwkgKgorCSAqIFdlIGFsbG93IHRoaXMgdG8g YmUgdHVybmVkIG9mZiBpZiB5b3Ugd2FudCB3aXRoCisJICogInZmcy56ZnNfZHluYW1pY193cml0 ZV9idWZmZXI9MCIsIHdoaWNoIGNhbiBiZSBkb25lIGluIHJlYWwgdGltZS4KKwkgKgorCSAqIE5v dGUgdGhhdCB3ZSB3b3JrIG9uIHRoZSB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgdmFyaWFi bGUsCisJICogYmVjYXVzZSB0aGUgdXNlciBtYXkgc2V0IHpmc19kaXJ0eV9kYXRhX21heCBoaW1z ZWxmIGFuZCB3ZSBtdXN0CisJICogbXVzdCBob25vciB0aGF0IGFzIGEgaGFyZCBjYXAgc28gaXQg cmVtYWlucyBhIHVzYWJsZSB0dW5hYmxlIHZhbHVlLgorCSAqLworCWlmICh6aW9fdXNlX3VtYSAm IHpmc19keW5hbWljX3dyaXRlX2J1ZmZlcikgeworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJu YWwgPSAxIDw8IDI4OworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBNQVgoemZzX2Rp cnR5X2RhdGFfbWF4X2ludGVybmFsLCBwdG9iKGNudC52X2ZyZWVfY291bnQgLSBjbnQudl9mcmVl X3RhcmdldCkpOworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBNSU4oemZzX2RpcnR5 X2RhdGFfbWF4X2ludGVybmFsLCB6ZnNfZGlydHlfZGF0YV9tYXgpOworCQl6ZnNfZGlydHlfZGF0 YV9tYXhfaW50ZXJuYWwgPSBNSU4oemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsLCB6ZnNfZGly dHlfZGF0YV9tYXhfbWF4KTsKKwkJaWYgKGxhc3RfbWF4ICE9ICh6ZnNfZGlydHlfZGF0YV9tYXhf aW50ZXJuYWwgLyAoMTAyNCAqIDEwMjQpKSkgeworCQkJbGFzdF9tYXggPSB6ZnNfZGlydHlfZGF0 YV9tYXhfaW50ZXJuYWwgLyAoMTAyNCAqIDEwMjQpOworCQkJRFRSQUNFX1BST0JFMShkbXVfX3R4 X2RpcnR5LCB1aW50NjRfdCwgbGFzdF9tYXgpOworCQl9CisJfSBlbHNlIHsKKwkJemZzX2RpcnR5 X2RhdGFfbWF4X2ludGVybmFsID0gemZzX2RpcnR5X2RhdGFfbWF4OworCX0KKyNlbmRpZiAvKiBf S0VSTkVMICovCisKIAl3aGlsZSAoKGVyciA9IGRtdV90eF90cnlfYXNzaWduKHR4LCB0eGdfaG93 KSkgIT0gMCkgewogCQlkbXVfdHhfdW5hc3NpZ24odHgpOwogCkBAIC0xMzIzLDcgKzEzNjIsNyBA QAogCQkgKiBzcGFjZS4KIAkJICovCiAJCW11dGV4X2VudGVyKCZkcC0+ZHBfbG9jayk7Ci0JCXdo aWxlIChkcC0+ZHBfZGlydHlfdG90YWwgPj0gemZzX2RpcnR5X2RhdGFfbWF4KQorCQl3aGlsZSAo ZHAtPmRwX2RpcnR5X3RvdGFsID49IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCkKIAkJCWN2 X3dhaXQoJmRwLT5kcF9zcGFjZWF2YWlsX2N2LCAmZHAtPmRwX2xvY2spOwogCQl1aW50NjRfdCBk aXJ0eSA9IGRwLT5kcF9kaXJ0eV90b3RhbDsKIAkJbXV0ZXhfZXhpdCgmZHAtPmRwX2xvY2spOwpJ bmRleDogc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9kc2xf cG9vbC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2Nv bW1vbi9mcy96ZnMvZHNsX3Bvb2wuYwkocmV2aXNpb24gMjg5MDc4KQorKysgc3lzL2NkZGwvY29u dHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9kc2xfcG9vbC5jCSh3b3JraW5nIGNv cHkpCkBAIC05OCw4ICs5OCwxMSBAQAogLyoKICAqIHpmc19kaXJ0eV9kYXRhX21heCB3aWxsIGJl IHNldCB0byB6ZnNfZGlydHlfZGF0YV9tYXhfcGVyY2VudCUgb2YgYWxsIG1lbW9yeSwKICAqIGNh cHBlZCBhdCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4LiAgSXQgY2FuIGFsc28gYmUgb3ZlcnJpZGRl biBpbiAvZXRjL3N5c3RlbS4KKyAqIFdlIGFsc28gZHluYW1pY2FsbHkgdHVuZSBkdXJpbmcgbG93 IG1lbW9yeSwgaG9ub3JpbmcgdGhlIHN5c2N0bCBzZXQsIHNvCisgKiBpbnRlcm5hbCBjb21wYXJp c29ucyBhcmUgYWdhaW5zdCB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwuCiAgKi8KIHVpbnQ2 NF90IHpmc19kaXJ0eV9kYXRhX21heDsKK3VpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heF9pbnRl cm5hbDsKIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heF9tYXggPSA0VUxMICogMTAyNCAqIDEw MjQgKiAxMDI0OwogaW50IHpmc19kaXJ0eV9kYXRhX21heF9wZXJjZW50ID0gMTA7CiAKQEAgLTU1 Nyw3ICs1NjAsNyBAQAogCSAqIE5vdGU6IHdlIHNpZ25hbCBldmVuIHdoZW4gaW5jcmVhc2luZyBk cF9kaXJ0eV90b3RhbC4KIAkgKiBUaGlzIGVuc3VyZXMgZm9yd2FyZCBwcm9ncmVzcyAtLSBlYWNo IHRocmVhZCB3YWtlcyB0aGUgbmV4dCB3YWl0ZXIuCiAJICovCi0JaWYgKGRwLT5kcF9kaXJ0eV90 b3RhbCA8PSB6ZnNfZGlydHlfZGF0YV9tYXgpCisJaWYgKGRwLT5kcF9kaXJ0eV90b3RhbCA8PSB6 ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwpCiAJCWN2X3NpZ25hbCgmZHAtPmRwX3NwYWNlYXZh aWxfY3YpOwogfQogCkBAIC03MzYsNyArNzM5LDcgQEAKIGRzbF9wb29sX25lZWRfZGlydHlfZGVs YXkoZHNsX3Bvb2xfdCAqZHApCiB7CiAJdWludDY0X3QgZGVsYXlfbWluX2J5dGVzID0KLQkgICAg emZzX2RpcnR5X2RhdGFfbWF4ICogemZzX2RlbGF5X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOwor CSAgICB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgKiB6ZnNfZGVsYXlfbWluX2RpcnR5X3Bl cmNlbnQgLyAxMDA7CiAJYm9vbGVhbl90IHJ2OwogCiAJbXV0ZXhfZW50ZXIoJmRwLT5kcF9sb2Nr KTsKSW5kZXg6IHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMv c3lzL2RzbF9wb29sLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJp cy91dHMvY29tbW9uL2ZzL3pmcy9zeXMvZHNsX3Bvb2wuaAkocmV2aXNpb24gMjg5MDc4KQorKysg c3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9zeXMvZHNsX3Bv b2wuaAkod29ya2luZyBjb3B5KQpAQCAtNTAsNiArNTAsNyBAQAogc3RydWN0IGRzbF9zY2FuOwog CiBleHRlcm4gdWludDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4OworZXh0ZXJuIHVpbnQ2NF90IHpm c19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbDsKIGV4dGVybiB1aW50NjRfdCB6ZnNfZGlydHlfZGF0 YV9tYXhfbWF4OwogZXh0ZXJuIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX3N5bmM7CiBleHRlcm4g aW50IHpmc19kaXJ0eV9kYXRhX21heF9wZXJjZW50OwpJbmRleDogc3lzL2NkZGwvY29udHJpYi9v cGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy96aW8uYwo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvY2Rk bC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3ppby5jCShyZXZpc2lvbiAy ODkwNzgpCisrKyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZz L3ppby5jCSh3b3JraW5nIGNvcHkpCkBAIC00MywxMCArNDMsMTMgQEAKIAogU1lTQ1RMX0RFQ0wo X3Zmc196ZnMpOwogU1lTQ1RMX05PREUoX3Zmc196ZnMsIE9JRF9BVVRPLCB6aW8sIENUTEZMQUdf UlcsIDAsICJaRlMgWklPIik7CisvKiBLRCAyMDE1LTA3LTE1IENoYW5nZSBjbGFzcyB0byAiaW50 IiBmcm9tICJzdGF0aWMgaW50IiBhcyB3ZSByZWZlcmVuY2UgCisgKiB0aGlzIGFzIGFuIGV4dGVy biBlbHNld2hlcmUKKyAqLwogI2lmIGRlZmluZWQoX19hbWQ2NF9fKQotc3RhdGljIGludCB6aW9f dXNlX3VtYSA9IDE7CitpbnQgemlvX3VzZV91bWEgPSAxOwogI2Vsc2UKLXN0YXRpYyBpbnQgemlv X3VzZV91bWEgPSAwOworaW50IHppb191c2VfdW1hID0gMDsKICNlbmRpZgogVFVOQUJMRV9JTlQo InZmcy56ZnMuemlvLnVzZV91bWEiLCAmemlvX3VzZV91bWEpOwogU1lTQ1RMX0lOVChfdmZzX3pm c196aW8sIE9JRF9BVVRPLCB1c2VfdW1hLCBDVExGTEFHX1JEVFVOLCAmemlvX3VzZV91bWEsIDAs Cg== 164051 2015-12-10 15:48:51 +0000 2015-12-10 15:48:51 +0000 Update of patch related to other bug report (see comment for details) patch-10.2-STABLE-r289078 text/plain 16255 karl SW5kZXg6IHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvYXJj LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9u L2ZzL3pmcy9hcmMuYwkocmV2aXNpb24gMjg5MDc4KQorKysgc3lzL2NkZGwvY29udHJpYi9vcGVu c29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMjE2LDYg KzIxNiwxNSBAQCBzdGF0aWMgaW50IGFyY19kZWFkOwogZXh0ZXJuIGJvb2xlYW5fdCB6ZnNfcHJl ZmV0Y2hfZGlzYWJsZTsKIAogLyoKKyAqIEtEIDIwMTUtMDItMTAKKyAqIFdlIGhhdmUgdG8gYmUg YWJsZSB0byB0ZXN0IGZvciBVSU8gdXNlIGluc2lkZSB0aGUgYXJjIGFsbG9jYXRvci4KKyAqIE5P VEU6IERPIE5PVCBNT0RJRlkgSEVSRSEKKyAqLworZXh0ZXJuIGludCB6aW9fdXNlX3VtYTsKK2V4 dGVybiBpbnQgemZzX2R5bmFtaWNfd3JpdGVfYnVmZmVyOworCisKKy8qCiAgKiBUaGUgYXJjIGhh cyBmaWxsZWQgYXZhaWxhYmxlIG1lbW9yeSBhbmQgaGFzIG5vdyB3YXJtZWQgdXAuCiAgKi8KIHN0 YXRpYyBib29sZWFuX3QgYXJjX3dhcm07CkBAIC0yMzMsNyArMjQyLDE1IEBAIGludCB6ZnNfYXJj X3BfbWluX3NoaWZ0ID0gMDsKIGludCB6ZnNfZGlzYWJsZV9kdXBfZXZpY3Rpb24gPSAwOwogdWlu dDY0X3QgemZzX2FyY19hdmVyYWdlX2Jsb2Nrc2l6ZSA9IDggKiAxMDI0OyAvKiA4S0IgKi8KIHVf aW50IHpmc19hcmNfZnJlZV90YXJnZXQgPSAwOwordV9pbnQgemZzX2FyY193YWtldXBfcGFnZXIg PSAwOwordV9pbnQgemZzX2FyY193YWtldXBfZGVsYXkgPSA1MDA7CiAKKyNkZWZpbmUJV0FLRV9Q QUdFUgorI2lmZGVmCVdBS0VfUEFHRVIKKyNkZWZpbmUJV0FLRV9QQUdFUl9DT05TVEFOVAkxMCAv IDkJCS8qIFBhZ2VyIHdha2V1cCB0aHJlc2hvbGQgKi8KK3N0YXRpYwlpbnQJYXJjX2luaXRfZG9u ZSA9IDA7CQkvKiBXZSBrbm93IGFyY193YXJtIGlzIHZhbGlkICovCisjZW5kaWYJLyogV0FLRV9Q QUdFUiAqLworCiBzdGF0aWMgaW50IHN5c2N0bF92ZnNfemZzX2FyY19mcmVlX3RhcmdldChTWVND VExfSEFORExFUl9BUkdTKTsKIHN0YXRpYyBpbnQgc3lzY3RsX3Zmc196ZnNfYXJjX21ldGFfbGlt aXQoU1lTQ1RMX0hBTkRMRVJfQVJHUyk7CiAKQEAgLTI0Miw3ICsyNTksMTAgQEAgc3RhdGljIHZv aWQKIGFyY19mcmVlX3RhcmdldF9pbml0KHZvaWQgKnVudXNlZCBfX3VudXNlZCkKIHsKIAotCXpm c19hcmNfZnJlZV90YXJnZXQgPSB2bV9wYWdlb3V0X3dha2V1cF90aHJlc2g7CisJemZzX2FyY19m cmVlX3RhcmdldCA9IHZtX3BhZ2VvdXRfd2FrZXVwX3RocmVzaCArICgoY250LnZfZnJlZV90YXJn ZXQgLSB2bV9wYWdlb3V0X3dha2V1cF90aHJlc2gpIC8gMik7CisjaWZkZWYJV0FLRV9QQUdFUgor CXpmc19hcmNfd2FrZXVwX3BhZ2VyID0gemZzX2FyY19mcmVlX3RhcmdldCAqIFdBS0VfUEFHRVJf Q09OU1RBTlQ7CisjZW5kaWYJLyogV0FLRV9QQUdFUiAqLwogfQogU1lTSU5JVChhcmNfZnJlZV90 YXJnZXRfaW5pdCwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfQU5ZLAogICAgIGFyY19m cmVlX3RhcmdldF9pbml0LCBOVUxMKTsKQEAgLTI2NCw3ICsyODQsMTUgQEAgU1lTQ1RMX1VRVUFE KF92ZnNfemZzLCBPSURfQVVUTywgYXJjX2F2ZXJhZ2VfYmxvY2sKIFNZU0NUTF9JTlQoX3Zmc196 ZnMsIE9JRF9BVVRPLCBhcmNfc2hyaW5rX3NoaWZ0LCBDVExGTEFHX1JXLAogICAgICZhcmNfc2hy aW5rX3NoaWZ0LCAwLAogICAgICJsb2cyKGZyYWN0aW9uIG9mIGFyYyB0byByZWNsYWltKSIpOwot CitTWVNDVExfSU5UKF92ZnNfemZzLCBPSURfQVVUTywgZHluYW1pY193cml0ZV9idWZmZXIsIENU TEZMQUdfUldUVU4sCisgICAgJnpmc19keW5hbWljX3dyaXRlX2J1ZmZlciwgMCwKKyAgICAiRHlu YW1pY2FsbHkgcmVzdHJpY3QgZGlydHkgZGF0YSB3aGVuIG1lbW9yeSBpcyBsb3ciKTsKKyNpZmRl ZglXQUtFX1BBR0VSCitTWVNDVExfVUlOVChfdmZzX3pmcywgT0lEX0FVVE8sIGFyY193YWtldXBf cGFnZXIsIENUTEZMQUdfUldUVU4sIAorCSZ6ZnNfYXJjX3dha2V1cF9wYWdlciwgMCwgIldha2Ug Vk0gYmVsb3cgdGhpcyBudW1iZXIgb2YgcGFnZXMiKTsKK1NZU0NUTF9VSU5UKF92ZnNfemZzLCBP SURfQVVUTywgYXJjX3dha2V1cF9kZWxheSwgQ1RMRkxBR19SV1RVTiwgCisJJnpmc19hcmNfd2Fr ZXVwX2RlbGF5LCAwLCAiTWF5IHdha2UgdXAgVk0gb25jZSB0aGlzIG51bWJlciBvZiBNUyIpOwor I2VuZGlmCS8qIFdBS0VfUEFHRVIgKi8KIC8qCiAgKiBXZSBkb24ndCBoYXZlIGEgdHVuYWJsZSBm b3IgYXJjX2ZyZWVfdGFyZ2V0IGR1ZSB0byB0aGUgZGVwZW5kZW5jeSBvbgogICogcGFnZWRhZW1v biBpbml0aWFsaXNhdGlvbi4KQEAgLTI5MSw2ICszMTksOSBAQCBzeXNjdGxfdmZzX3pmc19hcmNf ZnJlZV90YXJnZXQoU1lTQ1RMX0hBTkRMRVJfQVJHUwogCQlyZXR1cm4gKEVJTlZBTCk7CiAKIAl6 ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gdmFsOworI2lmZGVmCVdBS0VfUEFHRVIKKwl6ZnNfYXJjX3dh a2V1cF9wYWdlciA9IHpmc19hcmNfZnJlZV90YXJnZXQgKiBXQUtFX1BBR0VSX0NPTlNUQU5UOwor I2VuZGlmCS8qIFdBS0VfUEFHRVIgKi8KIAogCXJldHVybiAoMCk7CiB9CkBAIC0zMzY3LDYgKzMz OTgsMTEgQEAgaW50NjRfdCBhcmNfcGFnZXNfcHBfcmVzZXJ2ZSA9IDY0OwogaW50NjRfdCBhcmNf c3dhcGZzX3Jlc2VydmUgPSA2NDsKIAogLyoKKyAqIERlY2xhcmUgZmlsZS1sb2NhbCBzdGF0aWMg Zm9yIGV2ZW50IHByb2Nlc3NvciBieXBhc3MKKyAqLworc3RhdGljIHVuc2lnbmVkIGludCBhcmNf bm9fd2FrZV9ldmVudCA9IDA7CisKKy8qCiAgKiBSZXR1cm4gdGhlIGFtb3VudCBvZiBtZW1vcnkg dGhhdCBjYW4gYmUgY29uc3VtZWQgYmVmb3JlIHJlY2xhaW0gd2lsbCBiZQogICogbmVlZGVkLiAg UG9zaXRpdmUgaWYgdGhlcmUgaXMgc3VmZmljaWVudCBmcmVlIG1lbW9yeSwgbmVnYXRpdmUgaW5k aWNhdGVzCiAgKiB0aGUgYW1vdW50IG9mIG1lbW9yeSB0aGF0IG5lZWRzIHRvIGJlIGZyZWVkIHVw LgpAQCAtMzM3OSw2ICszNDE1LDEwIEBAIGFyY19hdmFpbGFibGVfbWVtb3J5KHZvaWQpCiAJZnJl ZV9tZW1vcnlfcmVhc29uX3QgciA9IEZNUl9VTktOT1dOOwogCiAjaWZkZWYgX0tFUk5FTAorI2lm ZGVmCVdBS0VfUEFHRVIKKwlzYmludGltZV90IG5vdzsKKwlzdGF0aWMgc2JpbnRpbWVfdCBsYXN0 X3BhZ2VkYWVtb25fd2FrZSA9IDA7CisjZW5kaWYJLyogV0FLRV9QQUdFUiAqLwogCWlmIChuZWVk ZnJlZSA+IDApIHsKIAkJbiA9IFBBR0VTSVpFICogKC1uZWVkZnJlZSk7CiAJCWlmIChuIDwgbG93 ZXN0KSB7CkBAIC0zMzk3LDYgKzM0MzcsMjYgQEAgYXJjX2F2YWlsYWJsZV9tZW1vcnkodm9pZCkK IAkJciA9IEZNUl9MT1RTRlJFRTsKIAl9CiAKKyNpZmRlZglXQUtFX1BBR0VSCisvKgorICogSWYg bWVtb3J5IGlzIGxlc3MgdGhhbiB0aGUgQVJDIHdha2V1cCB0aHJlc2hvbGQgYW5kIHRpbWUgaGFz IGV4cGlyZWQgc2luY2UKKyAqIHRoZSBsYXN0IHRpbWUgd2Ugd29rZSB0aGUgcGFnZXIuLi4gRG8g bm90IGV4ZWN1dGUgdW50aWwgdGhlIEFSQyB3YXJtcyB1cC4KKyAqLworCWlmICgoYXJjX2luaXRf ZG9uZSkgJiYKKwkJKCgoaW50NjRfdCkgZnJlZW1lbSAtIHpmc19hcmNfd2FrZXVwX3BhZ2VyKSA8 IDApICYmCisJCShhcmNfd2FybSA9PSBCX1RSVUUpCisJKSB7CisJCW5vdyA9IGdldHNiaW51cHRp bWUoKTsKKwkJaWYgKChub3cgLSBsYXN0X3BhZ2VkYWVtb25fd2FrZSkgLyBTQlRfMU1TID4gemZz X2FyY193YWtldXBfZGVsYXkpIHsKKwkJCWxhc3RfcGFnZWRhZW1vbl93YWtlID0gbm93OworCQkJ YXJjX25vX3dha2VfZXZlbnQrKzsJLyogU2V0IGJ5cGFzcyBmbGFnIGZvciBBUkMgKi8KKwkJCURU UkFDRV9QUk9CRShhcmNfX3dha2VfcGFnZWRhZW1vbik7CisJCQlwYWdlZGFlbW9uX3dha2V1cCgp OwkvKiBXYWtlIHRoZSBwYWdlciAqLworCQl9CisJfQorCisjZW5kaWYJLyogV0FLRV9QQUdFUiAq LworCiAjaWZkZWYgc3VuCiAJLyoKIAkgKiBjaGVjayB0aGF0IHdlJ3JlIG91dCBvZiByYW5nZSBv ZiB0aGUgcGFnZW91dCBzY2FubmVyLiAgSXQgc3RhcnRzIHRvCkBAIC0zNTA1LDYgKzM1NjUsNyBA QCBhcmNfYXZhaWxhYmxlX21lbW9yeSh2b2lkKQogCWxhc3RfZnJlZV9tZW1vcnkgPSBsb3dlc3Q7 CiAJbGFzdF9mcmVlX3JlYXNvbiA9IHI7CiAJRFRSQUNFX1BST0JFMihhcmNfX2F2YWlsYWJsZV9t ZW1vcnksIGludDY0X3QsIGxvd2VzdCwgaW50LCByKTsKKwogCXJldHVybiAobG93ZXN0KTsKIH0K IApAQCAtMzUyNCw2ICszNTg1LDQzIEBAIGV4dGVybiBrbWVtX2NhY2hlX3QJKnppb19idWZfY2Fj aGVbXTsKIGV4dGVybiBrbWVtX2NhY2hlX3QJKnppb19kYXRhX2J1Zl9jYWNoZVtdOwogZXh0ZXJu IGttZW1fY2FjaGVfdAkqcmFuZ2Vfc2VnX2NhY2hlOwogCisvKgorICogVXNlZCBieSBhcmNfa21l bV9yZWFwX25vdygpIGFuZCBjb25zaWRlcl9yZWFwaW5nX2FyY19jYWNoZXMoKQorICogdG8gbGlt aXQgdGhlIHRpbWUgc3BlbnQgcmVhcGluZy4KKyAqCisgKiBUaGUgYXJjX3JlYXBpbmdfaW5fcHJv Z3Jlc3MgaXMgYSAoc29tZXdoYXQgcmFjeSkgbGVmdCBvdmVyIGZyb20gYQorICogcHJldmlvdXMg dmVyc2lvbiBvZiB0aGlzIGNvZGUgd2hpY2ggY291bGQgdHJpZ2dlciBtdWx0aXBsZSBBUkMgY2Fj aGUKKyAqIHJlYXBpbmdzIGluIHBhcmFsbGVsIHdoaWNoIHNob3VsZCBiZSBhdm9pZGVkIHRvIHJl ZHVjZSBsb2NrCisgKiBjb250ZW50aW9uLiBJdCdzIGhhc24ndCBiZWVuIHJlbW92ZWQgeWV0IHRv IGVuY291cmFnZSBmdXJ0aGVyCisgKiBleHBlcmltZW50aW5nLgorICovCitzdGF0aWMgdW5zaWdu ZWQgaW50IGFyY19yZWFwaW5nX2luX3Byb2dyZXNzID0gMDsKK3N0YXRpYyB1bnNpZ25lZCBpbnQg YXJjX3BhZ2VkYWVtb25faWdub3JlID0gMDsKK3N0YXRpYyBzYmludGltZV90IGxhc3RfcmVhcGlu ZyA9IDA7CisKK3N0YXRpYyB2b2lkIF9fbm9pbmxpbmUKK3JlYXBfYXJjX2NhY2hlcyh2b2lkKQor eworCXNpemVfdCAgICAgICAgICBpOworCWttZW1fY2FjaGVfdCAgICAgICAgICAgICpwcmV2X2Nh Y2hlID0gTlVMTDsKKwlrbWVtX2NhY2hlX3QgICAgICAgICAgICAqcHJldl9kYXRhX2NhY2hlID0g TlVMTDsKKworCWZvciAoaSA9IDA7IGkgPCBTUEFfTUFYQkxPQ0tTSVpFID4+IFNQQV9NSU5CTE9D S1NISUZUOyBpKyspIHsKKwkJaWYgKHppb19idWZfY2FjaGVbaV0gIT0gcHJldl9jYWNoZSkgewor CQkJcHJldl9jYWNoZSA9IHppb19idWZfY2FjaGVbaV07CisJCQlrbWVtX2NhY2hlX3JlYXBfbm93 KHppb19idWZfY2FjaGVbaV0pOworCQl9CisJCWlmICh6aW9fZGF0YV9idWZfY2FjaGVbaV0gIT0g cHJldl9kYXRhX2NhY2hlKSB7CisJCQlwcmV2X2RhdGFfY2FjaGUgPSB6aW9fZGF0YV9idWZfY2Fj aGVbaV07CisJCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19kYXRhX2J1Zl9jYWNoZVtpXSk7CisJ CX0KKwl9CisJa21lbV9jYWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOworCWttZW1fY2FjaGVfcmVh cF9ub3coaGRyX2Z1bGxfY2FjaGUpOworCWttZW1fY2FjaGVfcmVhcF9ub3coaGRyX2wyb25seV9j YWNoZSk7CisJa21lbV9jYWNoZV9yZWFwX25vdyhyYW5nZV9zZWdfY2FjaGUpOworfQorCiBzdGF0 aWMgX19ub2lubGluZSB2b2lkCiBhcmNfa21lbV9yZWFwX25vdyh2b2lkKQogewpAQCAtMzUzMiw2 ICszNjMwLDggQEAgYXJjX2ttZW1fcmVhcF9ub3codm9pZCkKIAlrbWVtX2NhY2hlX3QJCSpwcmV2 X2RhdGFfY2FjaGUgPSBOVUxMOwogCiAJRFRSQUNFX1BST0JFKGFyY19fa21lbV9yZWFwX3N0YXJ0 KTsKKwlhcmNfcmVhcGluZ19pbl9wcm9ncmVzcysrOworCiAjaWZkZWYgX0tFUk5FTAogCWlmIChh cmNfbWV0YV91c2VkID49IGFyY19tZXRhX2xpbWl0KSB7CiAJCS8qCkBAIC0zNTQ4LDIwICszNjQ4 LDcgQEAgYXJjX2ttZW1fcmVhcF9ub3codm9pZCkKICNlbmRpZgogI2VuZGlmCiAKLQlmb3IgKGkg PSAwOyBpIDwgU1BBX01BWEJMT0NLU0laRSA+PiBTUEFfTUlOQkxPQ0tTSElGVDsgaSsrKSB7Ci0J CWlmICh6aW9fYnVmX2NhY2hlW2ldICE9IHByZXZfY2FjaGUpIHsKLQkJCXByZXZfY2FjaGUgPSB6 aW9fYnVmX2NhY2hlW2ldOwotCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6aW9fYnVmX2NhY2hlW2ld KTsKLQkJfQotCQlpZiAoemlvX2RhdGFfYnVmX2NhY2hlW2ldICE9IHByZXZfZGF0YV9jYWNoZSkg ewotCQkJcHJldl9kYXRhX2NhY2hlID0gemlvX2RhdGFfYnVmX2NhY2hlW2ldOwotCQkJa21lbV9j YWNoZV9yZWFwX25vdyh6aW9fZGF0YV9idWZfY2FjaGVbaV0pOwotCQl9Ci0JfQotCWttZW1fY2Fj aGVfcmVhcF9ub3coYnVmX2NhY2hlKTsKLQlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9mdWxsX2Nh Y2hlKTsKLQlrbWVtX2NhY2hlX3JlYXBfbm93KGhkcl9sMm9ubHlfY2FjaGUpOwotCWttZW1fY2Fj aGVfcmVhcF9ub3cocmFuZ2Vfc2VnX2NhY2hlKTsKKwlyZWFwX2FyY19jYWNoZXMoKTsKIAogI2lm ZGVmIHN1bgogCWlmICh6aW9fYXJlbmEgIT0gTlVMTCkgewpAQCAtMzU3MiwxMCArMzY1OSw1MSBA QCBhcmNfa21lbV9yZWFwX25vdyh2b2lkKQogCQl2bWVtX3FjYWNoZV9yZWFwKHppb19hcmVuYSk7 CiAJfQogI2VuZGlmCisjaWZkZWYgX0tFUk5FTAorCWxhc3RfcmVhcGluZyA9IGdldHNiaW51cHRp bWUoKTsKKyNlbmRpZgorCWFyY19yZWFwaW5nX2luX3Byb2dyZXNzID0gMDsKIAlEVFJBQ0VfUFJP QkUoYXJjX19rbWVtX3JlYXBfZW5kKTsKIH0KIAorCiAvKgorICogRGVjbGFyZWQgd3JpdGFibGUg dG8gYWxsb3cgcmVzZXR0aW5nIGl0LgorICogWFhYOiBTaG91bGQgcHJvYmFibHkgYmUgYSB1aW50 NjQgYW5kIGludGVncmF0ZWQgd2l0aCBrc3RhdC4KKyAqLworc3RhdGljIHVuc2lnbmVkIGludCBh cmNfY2FjaGVfcmVhcGluZ3Nfc2tpcHBlZCA9IDA7CitTWVNDVExfVUlOVChfdmZzX3pmcywgT0lE X0FVVE8sIGFyY19jYWNoZV9yZWFwaW5nc19za2lwcGVkLCBDVExGTEFHX1JXLAorICAgICZhcmNf Y2FjaGVfcmVhcGluZ3Nfc2tpcHBlZCwgMCwgIk51bWJlciBvZiB0aW1lcyB0aGUgQVJDIGNhY2hl cyBoYXZlIG5vdCBiZWVuIHJlYXBlZCBkdWUgdG8gdGhlIHJlYXAgZGVsYXkiKTsKKworc3RhdGlj IHVuc2lnbmVkIGludCBtaW5fYXJjX3JlYXBfZGVsYXkgPSAyMDA7CitTWVNDVExfVUlOVChfdmZz X3pmcywgT0lEX0FVVE8sIGFyY19yZWFwX2RlbGF5X21pbiwgQ1RMRkxBR19SVywKKyAgICAmbWlu X2FyY19yZWFwX2RlbGF5LCAyMDAsICJNaW5pbXVtIGRlbGF5IGJldHdlZW4gQVJDIGNhY2hlIHJl YXBpbmdzIChtaWxsaXNlY29uZHMpIik7CisKK3N0YXRpYyB2b2lkIF9fbm9pbmxpbmUKK2NvbnNp ZGVyX3JlYXBpbmdfYXJjX2NhY2hlcyh2b2lkKQoreworI2lmZGVmIF9LRVJORUwKKwlzYmludGlt ZV90IG5vdzsKKworCWlmIChhcmNfcmVhcGluZ19pbl9wcm9ncmVzcykKKwl7CisJCS8qIEFscmVh ZHkgcmVhcGluZyBpbiBhbm90aGVyIHRocmVhZC4gKi8KKwkJYXJjX2NhY2hlX3JlYXBpbmdzX3Nr aXBwZWQrKzsKKwkJcmV0dXJuOworCX0KKworCW5vdyA9IGdldHNiaW51cHRpbWUoKTsKKwlpZiAo KG5vdyAtIGxhc3RfcmVhcGluZykgLyBTQlRfMU1TIDwgbWluX2FyY19yZWFwX2RlbGF5KQorCXsK KwkJLyogVG9vIHNvb24gdG8gcmVhcCBhZ2Fpbi4gKi8KKwkJYXJjX2NhY2hlX3JlYXBpbmdzX3Nr aXBwZWQrKzsKKwkJcmV0dXJuOworCX0KKyNlbmRpZgorCWFyY19rbWVtX3JlYXBfbm93KCk7Cit9 CisKKy8qCiAgKiBUaHJlYWRzIGNhbiBibG9jayBpbiBhcmNfZ2V0X2RhdGFfYnVmKCkgd2FpdGlu ZyBmb3IgdGhpcyB0aHJlYWQgdG8gZXZpY3QKICAqIGVub3VnaCBkYXRhIGFuZCBzaWduYWwgdGhl bSB0byBwcm9jZWVkLiBXaGVuIHRoaXMgaGFwcGVucywgdGhlIHRocmVhZHMgaW4KICAqIGFyY19n ZXRfZGF0YV9idWYoKSBhcmUgc2xlZXBpbmcgd2hpbGUgaG9sZGluZyB0aGUgaGFzaCBsb2NrIGZv ciB0aGVpcgpAQCAtMzYxNyw4ICszNzQ1LDYgQEAgYXJjX3JlY2xhaW1fdGhyZWFkKHZvaWQgKmR1 bW15IF9fdW51c2VkKQogCQkJICovCiAJCQlncm93dGltZSA9IGRkaV9nZXRfbGJvbHQoKSArIChh cmNfZ3Jvd19yZXRyeSAqIGh6KTsKIAotCQkJYXJjX2ttZW1fcmVhcF9ub3coKTsKLQogCQkJLyoK IAkJCSAqIElmIHdlIGFyZSBzdGlsbCBsb3cgb24gbWVtb3J5LCBzaHJpbmsgdGhlIEFSQwogCQkJ ICogc28gdGhhdCB3ZSBoYXZlIGFyY19zaHJpbmtfbWluIGZyZWUgc3BhY2UuCkBAIC0zNjkyLDYg KzM4MTgsMTIgQEAgYXJjX3VzZXJfZXZpY3RzX3RocmVhZCh2b2lkICpkdW1teSBfX3VudXNlZCkK IAl3aGlsZSAoIWFyY191c2VyX2V2aWN0c190aHJlYWRfZXhpdCkgewogCQltdXRleF9leGl0KCZh cmNfdXNlcl9ldmljdHNfbG9jayk7CiAKKwkJLyoKKwkJICogQ29uc2lkZXIgcmVhcGluZyB0aGUg QVJDIGNhY2hlcyBhdCBsZWFzdCBvbmNlIHBlcgorCQkgKiBzZWNvbmQsIGJ1dCBtb3JlIG9mdGVu IHdoZW4gc2lnbmFsbGVkIHVuZGVyIHByZXNzdXJlLgorCQkgKi8KKwkJY29uc2lkZXJfcmVhcGlu Z19hcmNfY2FjaGVzKCk7CisKIAkJYXJjX2RvX3VzZXJfZXZpY3RzKCk7CiAKIAkJLyoKQEAgLTUy NDMsNyArNTM3NSwxMCBAQCBzdGF0aWMgZXZlbnRoYW5kbGVyX3RhZyBhcmNfZXZlbnRfbG93bWVt ID0gTlVMTDsKIHN0YXRpYyB2b2lkCiBhcmNfbG93bWVtKHZvaWQgKmFyZyBfX3VudXNlZCwgaW50 IGhvd3RvIF9fdW51c2VkKQogewotCisJaWYgKGFyY19ub193YWtlX2V2ZW50KSB7CS8qIERvbid0 IGRvIGl0IGlmIHdlIHdva2UgdGhlIHBhZ2VyICovCisJCWFyY19ub193YWtlX2V2ZW50ID0gMDsJ LyogSnVzdCBjbGVhciB0aGUgZmxhZyAqLworCQlyZXR1cm47CisJfQogCW11dGV4X2VudGVyKCZh cmNfcmVjbGFpbV9sb2NrKTsKIAkvKiBYWFg6IE1lbW9yeSBkZWZpY2l0IHNob3VsZCBiZSBwYXNz ZWQgYXMgYXJndW1lbnQuICovCiAJbmVlZGZyZWUgPSBidG9jKGFyY19jID4+IGFyY19zaHJpbmtf c2hpZnQpOwpAQCAtNTQ5MSw2ICs1NjI2LDkgQEAgYXJjX2luaXQodm9pZCkKIAkJcHJpbnRmKCIg ICAgICAgICAgICAgaW4gL2Jvb3QvbG9hZGVyLmNvbmYuXG4iKTsKIAl9CiAjZW5kaWYKKyNpZmRl ZglXQUtFX1BBR0VSCisJYXJjX2luaXRfZG9uZSsrOwkvKiBGb3IgYW55b25lIHdobyB3YW50cyB0 byBrbm93ICovCisjZW5kaWYJLyogV0FLRV9QQUdFUiAqLwogfQogCiB2b2lkCkluZGV4OiBzeXMv Y2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RtdV90eC5jCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMv ZG11X3R4LmMJKHJldmlzaW9uIDI4OTA3OCkKKysrIHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFy aXMvdXRzL2NvbW1vbi9mcy96ZnMvZG11X3R4LmMJKHdvcmtpbmcgY29weSkKQEAgLTQyLDYgKzQy LDggQEAKIHR5cGVkZWYgdm9pZCAoKmRtdV90eF9ob2xkX2Z1bmNfdCkoZG11X3R4X3QgKnR4LCBz dHJ1Y3QgZG5vZGUgKmRuLAogICAgIHVpbnQ2NF90IGFyZzEsIHVpbnQ2NF90IGFyZzIpOwogCitl eHRlcm4JaW50CXppb191c2VfdW1hOwkvKiBOZWVkcyB0byBiZSB2aXNpYmxlOyBETyBOT1QgTU9E SUZZISAqLworaW50CXpmc19keW5hbWljX3dyaXRlX2J1ZmZlciA9IDE7CS8qIER5bmFtaWNhbGx5 IHR1bmUgd3JpdGVzICovCiAKIGRtdV90eF90ICoKIGRtdV90eF9jcmVhdGVfZGQoZHNsX2Rpcl90 ICpkZCkKQEAgLTEwNjAsNyArMTA2Miw3IEBAIGRtdV90eF9kZWxheShkbXVfdHhfdCAqdHgsIHVp bnQ2NF90IGRpcnR5KQogewogCWRzbF9wb29sX3QgKmRwID0gdHgtPnR4X3Bvb2w7CiAJdWludDY0 X3QgZGVsYXlfbWluX2J5dGVzID0KLQkgICAgemZzX2RpcnR5X2RhdGFfbWF4ICogemZzX2RlbGF5 X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOworCSAgICB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJu YWwgKiB6ZnNfZGVsYXlfbWluX2RpcnR5X3BlcmNlbnQgLyAxMDA7CiAJaHJ0aW1lX3Qgd2FrZXVw LCBtaW5fdHhfdGltZSwgbm93OwogCiAJaWYgKGRpcnR5IDw9IGRlbGF5X21pbl9ieXRlcykKQEAg LTEwNzIsMTEgKzEwNzQsMTYgQEAgZG11X3R4X2RlbGF5KGRtdV90eF90ICp0eCwgdWludDY0X3Qg ZGlydHkpCiAJICogaGF2ZSB0byBoYW5kbGUgdGhlIGNhc2Ugb2YgaXQgYmVpbmcgPj0gdGhlIG1h eCwgd2hpY2ggY291bGQKIAkgKiBjYXVzZSBhIGRpdmlkZS1ieS16ZXJvIGlmIGl0J3MgPT0gdGhl IG1heC4KIAkgKi8KLQlBU1NFUlQzVShkaXJ0eSwgPCwgemZzX2RpcnR5X2RhdGFfbWF4KTsKKwlB U1NFUlQzVShkaXJ0eSwgPCwgemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsKTsKIAogCW5vdyA9 IGdldGhydGltZSgpOwotCW1pbl90eF90aW1lID0gemZzX2RlbGF5X3NjYWxlICoKLQkgICAgKGRp cnR5IC0gZGVsYXlfbWluX2J5dGVzKSAvICh6ZnNfZGlydHlfZGF0YV9tYXggLSBkaXJ0eSk7CisJ aWYgKGRpcnR5ID49IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbCkgey8qIE5vIHNjYWxpbmcg aWYgb3ZlcmNvbW1pdHRlZCAqLworCQltaW5fdHhfdGltZSA9IHpmc19kZWxheV9zY2FsZSAqCisJ CSAgICAoZGlydHkgLSBkZWxheV9taW5fYnl0ZXMpOworCX0gZWxzZSB7CisJCW1pbl90eF90aW1l ID0gemZzX2RlbGF5X3NjYWxlICoKKwkJICAgIChkaXJ0eSAtIGRlbGF5X21pbl9ieXRlcykgLyAo emZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsIC0gZGlydHkpOworCX0KIAlpZiAobm93ID4gdHgt PnR4X3N0YXJ0ICsgbWluX3R4X3RpbWUpCiAJCXJldHVybjsKIApAQCAtMTI4MSw2ICsxMjg4LDcg QEAgaW50CiBkbXVfdHhfYXNzaWduKGRtdV90eF90ICp0eCwgdHhnX2hvd190IHR4Z19ob3cpCiB7 CiAJaW50IGVycjsKKwlzdGF0aWMJdWludDY0X3QJbGFzdF9tYXg7CiAKIAlBU1NFUlQodHgtPnR4 X3R4ZyA9PSAwKTsKIAlBU1NFUlQodHhnX2hvdyA9PSBUWEdfV0FJVCB8fCB0eGdfaG93ID09IFRY R19OT1dBSVQgfHwKQEAgLTEyOTMsNiArMTMwMSw0MiBAQCBkbXVfdHhfYXNzaWduKGRtdV90eF90 ICp0eCwgdHhnX2hvd190IHR4Z19ob3cpCiAJaWYgKHR4Z19ob3cgPT0gVFhHX1dBSVRFRCkKIAkJ dHgtPnR4X3dhaXRlZCA9IEJfVFJVRTsKIAorI2lmZGVmIF9LRVJORUwKKwkvKgorCSAqIEtEIDIw MTQtMDktMjIKKwkgKiBJZiBVTUEgaXMgZW5hYmxlZCBpdCBjYW4gb25seSByZXR1cm4gYSBwcmV2 aW91c2x5LXVzZWQgYmxvY2sKKwkgKiBvZiBpZGVudGljYWwgc2l6ZSB0byB3aGF0IGl0IGhhZCBv dXQgYmVmb3JlLiAgSWYgaXQncyBub3QgdGhlCisJICogc2FtZSBzaXplIGl0IHdpbGwgYWxsb2Nh dGUgYSBuZXcgb25lLiAgVGhpcyBpcyBhIHByb2JsZW0gYmVjYXVzZQorCSAqIGRpcnR5X2RhdGFf bWF4IGlzIHRoZSB0b3RhbCBkaXJ0eSB3cml0ZSBkYXRhIGFsbG93ZWQgb3V0IGF0IGFueQorCSAq IGdpdmVuIHRpbWUsIGJ1dCB3aXRoIFVNQSBvbiB0aGF0IGNhbiBtdWx0aXBseSBieSB0aGUgbnVt YmVyIG9mCisJICogZGlmZmVyZW50IGJsb2NrIHNpemVzICghISkgcmVxdWVzdGVkIGluIHRlcm1z IG9mIGZyZWUgUkFNIHRoYXQKKwkgKiBpcyBsZWZ0IGFsbG9jYXRlZCBidXQgdW51c2VkLiAgRm9y IHRoaXMgcmVhc29uIG5ldmVyIGFsbG93CisJICogZGlydHlfZGF0YV9tYXggdG8gZXhjZWVkIHRo ZSBkaWZmZXJlbmNlIGJldHdlZW4gdGhlIHBhZ2luZworCSAqIHRocmVzaG9sZCBhbmQgdGhlIGN1 cnJlbnQgZnJlZSBtZW1vcnksIHdpdGggYSBtaW5pbXVtIG9mIDI1Nk1CLgorCSAqIFRoaXMgdGhy b3R0bGVzICJidXJzdCIgYWxsb2NhdGlvbnMgYW5kIHByZXZlbnRzIHRoZSBzeXN0ZW0gZnJvbQor CSAqIGNob2tpbmcgZHVyaW5nIHRpbWVzIG9mIGhpZ2ggd3JpdGUgSS9PIGRlbWFuZC4KKwkgKgor CSAqIFdlIGFsbG93IHRoaXMgdG8gYmUgdHVybmVkIG9mZiBpZiB5b3Ugd2FudCB3aXRoCisJICog InZmcy56ZnNfZHluYW1pY193cml0ZV9idWZmZXI9MCIsIHdoaWNoIGNhbiBiZSBkb25lIGluIHJl YWwgdGltZS4KKwkgKgorCSAqIE5vdGUgdGhhdCB3ZSB3b3JrIG9uIHRoZSB6ZnNfZGlydHlfZGF0 YV9tYXhfaW50ZXJuYWwgdmFyaWFibGUsCisJICogYmVjYXVzZSB0aGUgdXNlciBtYXkgc2V0IHpm c19kaXJ0eV9kYXRhX21heCBoaW1zZWxmIGFuZCB3ZSBtdXN0CisJICogbXVzdCBob25vciB0aGF0 IGFzIGEgaGFyZCBjYXAgc28gaXQgcmVtYWlucyBhIHVzYWJsZSB0dW5hYmxlIHZhbHVlLgorCSAq LworCWlmICh6aW9fdXNlX3VtYSAmIHpmc19keW5hbWljX3dyaXRlX2J1ZmZlcikgeworCQl6ZnNf ZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSAxIDw8IDI4OworCQl6ZnNfZGlydHlfZGF0YV9tYXhf aW50ZXJuYWwgPSBNQVgoemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsLCBwdG9iKGNudC52X2Zy ZWVfY291bnQgLSBjbnQudl9mcmVlX3RhcmdldCkpOworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50 ZXJuYWwgPSBNSU4oemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsLCB6ZnNfZGlydHlfZGF0YV9t YXgpOworCQl6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgPSBNSU4oemZzX2RpcnR5X2RhdGFf bWF4X2ludGVybmFsLCB6ZnNfZGlydHlfZGF0YV9tYXhfbWF4KTsKKwkJaWYgKGxhc3RfbWF4ICE9 ICh6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgLyAoMTAyNCAqIDEwMjQpKSkgeworCQkJbGFz dF9tYXggPSB6ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgLyAoMTAyNCAqIDEwMjQpOworCQkJ RFRSQUNFX1BST0JFMShkbXVfX3R4X2RpcnR5LCB1aW50NjRfdCwgbGFzdF9tYXgpOworCQl9CisJ fSBlbHNlIHsKKwkJemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsID0gemZzX2RpcnR5X2RhdGFf bWF4OworCX0KKyNlbmRpZiAvKiBfS0VSTkVMICovCisKIAl3aGlsZSAoKGVyciA9IGRtdV90eF90 cnlfYXNzaWduKHR4LCB0eGdfaG93KSkgIT0gMCkgewogCQlkbXVfdHhfdW5hc3NpZ24odHgpOwog CkBAIC0xMzIzLDcgKzEzNjcsNyBAQCBkbXVfdHhfd2FpdChkbXVfdHhfdCAqdHgpCiAJCSAqIHNw YWNlLgogCQkgKi8KIAkJbXV0ZXhfZW50ZXIoJmRwLT5kcF9sb2NrKTsKLQkJd2hpbGUgKGRwLT5k cF9kaXJ0eV90b3RhbCA+PSB6ZnNfZGlydHlfZGF0YV9tYXgpCisJCXdoaWxlIChkcC0+ZHBfZGly dHlfdG90YWwgPj0gemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsKQogCQkJY3Zfd2FpdCgmZHAt PmRwX3NwYWNlYXZhaWxfY3YsICZkcC0+ZHBfbG9jayk7CiAJCXVpbnQ2NF90IGRpcnR5ID0gZHAt PmRwX2RpcnR5X3RvdGFsOwogCQltdXRleF9leGl0KCZkcC0+ZHBfbG9jayk7CkluZGV4OiBzeXMv Y2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RzbF9wb29sLmMKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pm cy9kc2xfcG9vbC5jCShyZXZpc2lvbiAyODkwNzgpCisrKyBzeXMvY2RkbC9jb250cmliL29wZW5z b2xhcmlzL3V0cy9jb21tb24vZnMvemZzL2RzbF9wb29sLmMJKHdvcmtpbmcgY29weSkKQEAgLTk4 LDggKzk4LDExIEBACiAvKgogICogemZzX2RpcnR5X2RhdGFfbWF4IHdpbGwgYmUgc2V0IHRvIHpm c19kaXJ0eV9kYXRhX21heF9wZXJjZW50JSBvZiBhbGwgbWVtb3J5LAogICogY2FwcGVkIGF0IHpm c19kaXJ0eV9kYXRhX21heF9tYXguICBJdCBjYW4gYWxzbyBiZSBvdmVycmlkZGVuIGluIC9ldGMv c3lzdGVtLgorICogV2UgYWxzbyBkeW5hbWljYWxseSB0dW5lIGR1cmluZyBsb3cgbWVtb3J5LCBo b25vcmluZyB0aGUgc3lzY3RsIHNldCwgc28KKyAqIGludGVybmFsIGNvbXBhcmlzb25zIGFyZSBh Z2FpbnN0IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbC4KICAqLwogdWludDY0X3QgemZzX2Rp cnR5X2RhdGFfbWF4OwordWludDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4X2ludGVybmFsOwogdWlu dDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4X21heCA9IDRVTEwgKiAxMDI0ICogMTAyNCAqIDEwMjQ7 CiBpbnQgemZzX2RpcnR5X2RhdGFfbWF4X3BlcmNlbnQgPSAxMDsKIApAQCAtNTU3LDcgKzU2MCw3 IEBAIGRzbF9wb29sX2RpcnR5X2RlbHRhKGRzbF9wb29sX3QgKmRwLCBpbnQ2NF90IGRlbHRhCiAJ ICogTm90ZTogd2Ugc2lnbmFsIGV2ZW4gd2hlbiBpbmNyZWFzaW5nIGRwX2RpcnR5X3RvdGFsLgog CSAqIFRoaXMgZW5zdXJlcyBmb3J3YXJkIHByb2dyZXNzIC0tIGVhY2ggdGhyZWFkIHdha2VzIHRo ZSBuZXh0IHdhaXRlci4KIAkgKi8KLQlpZiAoZHAtPmRwX2RpcnR5X3RvdGFsIDw9IHpmc19kaXJ0 eV9kYXRhX21heCkKKwlpZiAoZHAtPmRwX2RpcnR5X3RvdGFsIDw9IHpmc19kaXJ0eV9kYXRhX21h eF9pbnRlcm5hbCkKIAkJY3Zfc2lnbmFsKCZkcC0+ZHBfc3BhY2VhdmFpbF9jdik7CiB9CiAKQEAg LTczNiw3ICs3MzksNyBAQCBib29sZWFuX3QKIGRzbF9wb29sX25lZWRfZGlydHlfZGVsYXkoZHNs X3Bvb2xfdCAqZHApCiB7CiAJdWludDY0X3QgZGVsYXlfbWluX2J5dGVzID0KLQkgICAgemZzX2Rp cnR5X2RhdGFfbWF4ICogemZzX2RlbGF5X21pbl9kaXJ0eV9wZXJjZW50IC8gMTAwOworCSAgICB6 ZnNfZGlydHlfZGF0YV9tYXhfaW50ZXJuYWwgKiB6ZnNfZGVsYXlfbWluX2RpcnR5X3BlcmNlbnQg LyAxMDA7CiAJYm9vbGVhbl90IHJ2OwogCiAJbXV0ZXhfZW50ZXIoJmRwLT5kcF9sb2NrKTsKSW5k ZXg6IHN5cy9jZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMvc3lzL2Rz bF9wb29sLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2NkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMv Y29tbW9uL2ZzL3pmcy9zeXMvZHNsX3Bvb2wuaAkocmV2aXNpb24gMjg5MDc4KQorKysgc3lzL2Nk ZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9zeXMvZHNsX3Bvb2wuaAko d29ya2luZyBjb3B5KQpAQCAtNTAsNiArNTAsNyBAQCBzdHJ1Y3QgZG11X3R4Owogc3RydWN0IGRz bF9zY2FuOwogCiBleHRlcm4gdWludDY0X3QgemZzX2RpcnR5X2RhdGFfbWF4OworZXh0ZXJuIHVp bnQ2NF90IHpmc19kaXJ0eV9kYXRhX21heF9pbnRlcm5hbDsKIGV4dGVybiB1aW50NjRfdCB6ZnNf ZGlydHlfZGF0YV9tYXhfbWF4OwogZXh0ZXJuIHVpbnQ2NF90IHpmc19kaXJ0eV9kYXRhX3N5bmM7 CiBleHRlcm4gaW50IHpmc19kaXJ0eV9kYXRhX21heF9wZXJjZW50OwpJbmRleDogc3lzL2NkZGwv Y29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy96aW8uYwo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21tb24vZnMvemZzL3ppby5jCShy ZXZpc2lvbiAyODkwNzgpCisrKyBzeXMvY2RkbC9jb250cmliL29wZW5zb2xhcmlzL3V0cy9jb21t b24vZnMvemZzL3ppby5jCSh3b3JraW5nIGNvcHkpCkBAIC00MywxMCArNDMsMTMgQEAKIAogU1lT Q1RMX0RFQ0woX3Zmc196ZnMpOwogU1lTQ1RMX05PREUoX3Zmc196ZnMsIE9JRF9BVVRPLCB6aW8s IENUTEZMQUdfUlcsIDAsICJaRlMgWklPIik7CisvKiBLRCAyMDE1LTA3LTE1IENoYW5nZSBjbGFz cyB0byAiaW50IiBmcm9tICJzdGF0aWMgaW50IiBhcyB3ZSByZWZlcmVuY2UgCisgKiB0aGlzIGFz IGFuIGV4dGVybiBlbHNld2hlcmUKKyAqLwogI2lmIGRlZmluZWQoX19hbWQ2NF9fKQotc3RhdGlj IGludCB6aW9fdXNlX3VtYSA9IDE7CitpbnQgemlvX3VzZV91bWEgPSAxOwogI2Vsc2UKLXN0YXRp YyBpbnQgemlvX3VzZV91bWEgPSAwOworaW50IHppb191c2VfdW1hID0gMDsKICNlbmRpZgogVFVO QUJMRV9JTlQoInZmcy56ZnMuemlvLnVzZV91bWEiLCAmemlvX3VzZV91bWEpOwogU1lTQ1RMX0lO VChfdmZzX3pmc196aW8sIE9JRF9BVVRPLCB1c2VfdW1hLCBDVExGTEFHX1JEVFVOLCAmemlvX3Vz ZV91bWEsIDAsCg== 174197 2016-08-29 17:24:13 +0000 2016-08-30 20:23:02 +0000 First cut against 11.0-STABLE patch-11.0-STABLE-r305005 text/plain 3516 karl SW5kZXg6IGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMv YXJjLmMJKHJldmlzaW9uIDMwNTAwNSkKKysrIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMv Y29tbW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMjM3LDcgKzIzNywxNiBAQCBp bnQgemZzX2FyY19wX21pbl9zaGlmdCA9IDA7CiBpbnQgemZzX2Rpc2FibGVfZHVwX2V2aWN0aW9u ID0gMDsKIHVpbnQ2NF90IHpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUgPSA4ICogMTAyNDsgLyog OEtCICovCiB1X2ludCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gMDsKK3VfaW50IHpmc19hcmNfd2Fr ZXVwX3BhZ2VyID0gMDsKK3VfaW50IHpmc19hcmNfd2FrZXVwX2RlbGF5ID0gNTAwOwogCisjZGVm aW5lCVdBS0VfUEFHRVIKKyNpZmRlZglXQUtFX1BBR0VSCisjZGVmaW5lCVdBS0VfUEFHRVJfQ09O U1RBTlQJMTAgLyA5CS8qIFBhZ2VyIHdha2V1cCB0aHJlc2hvbGQgKi8KK3N0YXRpYwlpbnQJYXJj X2luaXRfZG9uZSA9IDA7CS8qIEFmdGVyIGFyY193YXJtIGlzIHZhbGlkICovCitleHRlcm4gdm9p ZCBwYWdlZGFlbW9uX3dha2V1cCh2b2lkKTsKKyNlbmRpZgorCiAvKiBBYnNvbHV0ZSBtaW4gZm9y IGFyYyBtaW4gLyBtYXggaXMgMTZNQi4gKi8KIHN0YXRpYyB1aW50NjRfdCBhcmNfYWJzX21pbiA9 IDE2IDw8IDIwOwogCkBAIC0yNTIsNiArMjYxLDcgQEAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQodm9p ZCAqdW51c2VkIF9fdW51c2VkKQogewogCiAJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3BhZ2Vv dXRfd2FrZXVwX3RocmVzaDsKKwl6ZnNfYXJjX3dha2V1cF9wYWdlciA9IHpmc19hcmNfZnJlZV90 YXJnZXQgKiBXQUtFX1BBR0VSX0NPTlNUQU5UOwogfQogU1lTSU5JVChhcmNfZnJlZV90YXJnZXRf aW5pdCwgU0lfU1VCX0tUSFJFQURfUEFHRSwgU0lfT1JERVJfQU5ZLAogICAgIGFyY19mcmVlX3Rh cmdldF9pbml0LCBOVUxMKTsKQEAgLTM0NzYsNiArMzQ4NiwxMSBAQCBpbnQ2NF90IGFyY19wYWdl c19wcF9yZXNlcnZlID0gNjQ7CiBpbnQ2NF90IGFyY19zd2FwZnNfcmVzZXJ2ZSA9IDY0OwogCiAv KgorICogRGVjbGFyZSBmaWxlLWxvY2FsIHN0YXRpYyBmb3IgZXZlbnQgcHJvY2Vzc29yIGJ5cGFz cworICovCitzdGF0aWMgdW5zaWduZWQgaW50IGFyY19ub193YWtlX2V2ZW50ID0gMDsKKworLyoK ICAqIFJldHVybiB0aGUgYW1vdW50IG9mIG1lbW9yeSB0aGF0IGNhbiBiZSBjb25zdW1lZCBiZWZv cmUgcmVjbGFpbSB3aWxsIGJlCiAgKiBuZWVkZWQuICBQb3NpdGl2ZSBpZiB0aGVyZSBpcyBzdWZm aWNpZW50IGZyZWUgbWVtb3J5LCBuZWdhdGl2ZSBpbmRpY2F0ZXMKICAqIHRoZSBhbW91bnQgb2Yg bWVtb3J5IHRoYXQgbmVlZHMgdG8gYmUgZnJlZWQgdXAuCkBAIC0zNDg4LDYgKzM1MDMsMTIgQEAg YXJjX2F2YWlsYWJsZV9tZW1vcnkodm9pZCkKIAlmcmVlX21lbW9yeV9yZWFzb25fdCByID0gRk1S X1VOS05PV047CiAKICNpZmRlZiBfS0VSTkVMCisjaWZkZWYgV0FLRV9QQUdFUgorCXNiaW50aW1l X3Qgbm93OworCXN0YXRpYyBzYmludGltZV90IGxhc3RfcGFnZWRhZW1vbl93YWtlID0gMDsKKwl2 b2lkIGNhbGxfYXJjX2ttZW1fcmVhcCh2b2lkKTsKKyNlbmRpZgkvKiBXQUtFX1BBR0VSICovCisK IAlpZiAobmVlZGZyZWUgPiAwKSB7CiAJCW4gPSBQQUdFU0laRSAqICgtbmVlZGZyZWUpOwogCQlp ZiAobiA8IGxvd2VzdCkgewpAQCAtMzQ5NSw2ICszNTE2LDI1IEBAIGFyY19hdmFpbGFibGVfbWVt b3J5KHZvaWQpCiAJCQlyID0gRk1SX05FRURGUkVFOwogCQl9CiAJfQorI2lmZGVmIFdBS0VfUEFH RVIKKy8qCisgKiBJZiBtZW1vcnkgaXMgbGVzcyB0aGFuIHRoZSBBUkMgd2FrZXVwIHRocmVzaG9s ZCBhbmQgdGltZSBoYXMgZXhwaXJlZCBzaW5jZQorICogdGhlIGxhc3QgdGltZSB3ZSB3b2tlIHRo ZSBwYWdlci4uLiBEbyBub3QgZXhlY3V0ZSB1bnRpbCB0aGUgQVJDIHdhcm1zIHVwLgorICovCisJ aWYgKChhcmNfaW5pdF9kb25lKSAmJgorCQkoKChpbnQ2NF90KSBmcmVlbWVtIC0gemZzX2FyY193 YWtldXBfcGFnZXIpIDwgMCkgJiYKKwkJKGFyY193YXJtID09IEJfVFJVRSkKKwkpIHsKKwkJbm93 ID0gZ2V0c2JpbnVwdGltZSgpOworCQlpZiAoKG5vdyAtIGxhc3RfcGFnZWRhZW1vbl93YWtlKSAv IFNCVF8xTVMgPiB6ZnNfYXJjX3dha2V1cF9kZWxheSkgeworCQkJbGFzdF9wYWdlZGFlbW9uX3dh a2UgPSBub3c7CisJCQlhcmNfbm9fd2FrZV9ldmVudCsrOyAgICAvKiBTZXQgYnlwYXNzIGZsYWcg Zm9yIEFSQyAqLworCQkJY2FsbF9hcmNfa21lbV9yZWFwKCk7CS8qIFJlYXAgY2FjaGVzIGlmIHdl J3JlIGNsb3NlICovCisJCQlEVFJBQ0VfUFJPQkUoYXJjX193YWtlX3BhZ2VkYWVtb24pOworCQkJ KHZvaWQpIHBhZ2VkYWVtb25fd2FrZXVwKCk7ICAgIC8qIFdha2UgdGhlIHBhZ2VyICovCisJCX0K Kwl9CisjZW5kaWYgLyogV0FLRV9QQUdFUiAqLwogCiAJLyoKIAkgKiBDb29wZXJhdGUgd2l0aCBw YWdlZGFlbW9uIHdoZW4gaXQncyB0aW1lIGZvciBpdCB0byBzY2FuCkBAIC0zNjg0LDYgKzM3MjQs MTEgQEAgYXJjX2ttZW1fcmVhcF9ub3codm9pZCkKIAlEVFJBQ0VfUFJPQkUoYXJjX19rbWVtX3Jl YXBfZW5kKTsKIH0KIAordm9pZAljYWxsX2FyY19rbWVtX3JlYXAoKQoreworCWFyY19rbWVtX3Jl YXBfbm93KCk7Cit9CisKIC8qCiAgKiBUaHJlYWRzIGNhbiBibG9jayBpbiBhcmNfZ2V0X2RhdGFf YnVmKCkgd2FpdGluZyBmb3IgdGhpcyB0aHJlYWQgdG8gZXZpY3QKICAqIGVub3VnaCBkYXRhIGFu ZCBzaWduYWwgdGhlbSB0byBwcm9jZWVkLiBXaGVuIHRoaXMgaGFwcGVucywgdGhlIHRocmVhZHMg aW4KQEAgLTU0MzEsNiArNTQ3NiwxMCBAQCBzdGF0aWMgZXZlbnRoYW5kbGVyX3RhZyBhcmNfZXZl bnRfbG93bWVtID0gTlVMTDsKIHN0YXRpYyB2b2lkCiBhcmNfbG93bWVtKHZvaWQgKmFyZyBfX3Vu dXNlZCwgaW50IGhvd3RvIF9fdW51c2VkKQogeworCWlmIChhcmNfbm9fd2FrZV9ldmVudCkgeyAg ICAgICAgLyogRG9uJ3QgZG8gaXQgaWYgd2Ugd29rZSB0aGUgcGFnZXIgKi8KKwkJYXJjX25vX3dh a2VfZXZlbnQgPSAwOyAgLyogSnVzdCBjbGVhciB0aGUgZmxhZyAqLworCQlyZXR1cm47CisJfQog CiAJbXV0ZXhfZW50ZXIoJmFyY19yZWNsYWltX2xvY2spOwogCS8qIFhYWDogTWVtb3J5IGRlZmlj aXQgc2hvdWxkIGJlIHBhc3NlZCBhcyBhcmd1bWVudC4gKi8KQEAgLTU2OTYsNiArNTc0NSw5IEBA IGFyY19pbml0KHZvaWQpCiAJCXByaW50ZigiICAgICAgICAgICAgIGluIC9ib290L2xvYWRlci5j b25mLlxuIik7CiAJfQogI2VuZGlmCisjaWZkZWYJV0FLRV9QQUdFUgorCWFyY19pbml0X2RvbmUr KzsKKyNlbmRpZgkvKiBXQUtFX1BBR0VSICovCiB9CiAKIHZvaWQK 174198 2016-08-29 17:36:05 +0000 2016-08-30 20:24:09 +0000 Dtrace script to track code execution in above patch against 11.0-STABLE wake-pagedaemon text/plain 91 karl IyEvdXNyL3NiaW4vZHRyYWNlIC1zCgpzZHQ6OjphcmMtd2FrZV9wYWdlZGFlbW9uCnsKICAgICAg ICBwcmludGYoIiVZIiwgd2FsbHRpbWVzdGFtcCk7Cn0KCg== 174231 2016-08-30 20:23:02 +0000 2016-08-31 15:00:37 +0000 Second cut against 11.0-STABLE patch-11.0-STABLE-r305005-rev2 text/plain 6348 karl SW5kZXg6IGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMv YXJjLmMJKHJldmlzaW9uIDMwNDk3MSkKKysrIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMv Y29tbW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMjM3LDcgKzIzNywxNyBAQCBp bnQgemZzX2FyY19wX21pbl9zaGlmdCA9IDA7CiBpbnQgemZzX2Rpc2FibGVfZHVwX2V2aWN0aW9u ID0gMDsKIHVpbnQ2NF90IHpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUgPSA4ICogMTAyNDsgLyog OEtCICovCiB1X2ludCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gMDsKK3VfaW50IHpmc19hcmNfd2Fr ZXVwX3BhZ2VyID0gMDsKK3VfaW50IHpmc19hcmNfd2FrZXVwX2RlbGF5ID0gNTAwOworaW50CXpm c19hcmNfbGFzdF9zbGFiID0gMDsKIAorI2RlZmluZQlXQUtFX1BBR0VSCisjaWZkZWYJV0FLRV9Q QUdFUgorI2RlZmluZQlXQUtFX1BBR0VSX0NPTlNUQU5UCTEwIC8gOQkvKiBQYWdlciB3YWtldXAg dGhyZXNob2xkICovCitzdGF0aWMJaW50CWFyY19pbml0X2RvbmUgPSAwOwkvKiBBZnRlciBhcmNf d2FybSBpcyB2YWxpZCAqLworZXh0ZXJuIHZvaWQgcGFnZWRhZW1vbl93YWtldXAodm9pZCk7Cisj ZW5kaWYKKwogLyogQWJzb2x1dGUgbWluIGZvciBhcmMgbWluIC8gbWF4IGlzIDE2TUIuICovCiBz dGF0aWMgdWludDY0X3QgYXJjX2Fic19taW4gPSAxNiA8PCAyMDsKIApAQCAtMjUxLDcgKzI2MSw4 IEBAIHN0YXRpYyB2b2lkCiBhcmNfZnJlZV90YXJnZXRfaW5pdCh2b2lkICp1bnVzZWQgX191bnVz ZWQpCiB7CiAKLQl6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gdm1fcGFnZW91dF93YWtldXBfdGhyZXNo OworCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2bV9wYWdlb3V0X3dha2V1cF90aHJlc2ggKyAodm1f cGFnZW91dF93YWtldXBfdGhyZXNoIC8gMjApOworCXpmc19hcmNfd2FrZXVwX3BhZ2VyID0gdm1f cGFnZW91dF93YWtldXBfdGhyZXNoICogV0FLRV9QQUdFUl9DT05TVEFOVDsKIH0KIFNZU0lOSVQo YXJjX2ZyZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX0FOWSwK ICAgICBhcmNfZnJlZV90YXJnZXRfaW5pdCwgTlVMTCk7CkBAIC0zNDc2LDYgKzM0ODcsMTEgQEAg aW50NjRfdCBhcmNfcGFnZXNfcHBfcmVzZXJ2ZSA9IDY0OwogaW50NjRfdCBhcmNfc3dhcGZzX3Jl c2VydmUgPSA2NDsKIAogLyoKKyAqIERlY2xhcmUgZmlsZS1sb2NhbCBzdGF0aWMgZm9yIGV2ZW50 IHByb2Nlc3NvciBieXBhc3MKKyAqLworc3RhdGljIHVuc2lnbmVkIGludCBhcmNfbm9fd2FrZV9l dmVudCA9IDA7CisKKy8qCiAgKiBSZXR1cm4gdGhlIGFtb3VudCBvZiBtZW1vcnkgdGhhdCBjYW4g YmUgY29uc3VtZWQgYmVmb3JlIHJlY2xhaW0gd2lsbCBiZQogICogbmVlZGVkLiAgUG9zaXRpdmUg aWYgdGhlcmUgaXMgc3VmZmljaWVudCBmcmVlIG1lbW9yeSwgbmVnYXRpdmUgaW5kaWNhdGVzCiAg KiB0aGUgYW1vdW50IG9mIG1lbW9yeSB0aGF0IG5lZWRzIHRvIGJlIGZyZWVkIHVwLgpAQCAtMzQ4 OCw2ICszNTA0LDEyIEBAIGFyY19hdmFpbGFibGVfbWVtb3J5KHZvaWQpCiAJZnJlZV9tZW1vcnlf cmVhc29uX3QgciA9IEZNUl9VTktOT1dOOwogCiAjaWZkZWYgX0tFUk5FTAorI2lmZGVmIFdBS0Vf UEFHRVIKKwlzYmludGltZV90IG5vdzsKKwlzdGF0aWMgc2JpbnRpbWVfdCBsYXN0X3BhZ2VkYWVt b25fd2FrZSA9IDA7CisJdm9pZCBjYWxsX2FyY19rbWVtX3JlYXAoaW50KTsKKyNlbmRpZgkvKiBX QUtFX1BBR0VSICovCisKIAlpZiAobmVlZGZyZWUgPiAwKSB7CiAJCW4gPSBQQUdFU0laRSAqICgt bmVlZGZyZWUpOwogCQlpZiAobiA8IGxvd2VzdCkgewpAQCAtMzQ5NSw2ICszNTE3LDM3IEBAIGFy Y19hdmFpbGFibGVfbWVtb3J5KHZvaWQpCiAJCQlyID0gRk1SX05FRURGUkVFOwogCQl9CiAJfQor I2lmZGVmIFdBS0VfUEFHRVIKKy8qCisgKiBXaGVuIGFyYyBpcyBpbml0aWFsaXplZCwgcGVyZm9y bSB0aGUgZm9sbG93aW5nOgorICoKKyAqIDEuIElmIHdlIGFyZSBpbiB0aGUgIm1lbW9yeSBpcyBs b3cgZW5vdWdoIHRvIHdha2UgdGhlIHBhZ2VyIiB6b25lLAorICogICAgcmVhcCB0aGUga2VybmVs IFVNQSBjYWNoZXMgb25jZSBwZXIgd2FrZXVwX2RlbGF5IHBlcmlvZCA1MDBtcyBkZWZhdWx0KQor ICogICAgQU5EIHdha2UgdGhlIHBhZ2VyIHVwIChzbyBpdCBjYW4gZGVtb3RlIHBhZ2VzIGZyb20g aW5hY3RpdmUgdG8gY2FjaGUgdG8KKyAqICAgIHVsdGltYXRlbHkgdGhlIGZyZWUgbGlzdC4pCisg KgorICogMi4gSWYgd2UncmUgYmVsb3cgVk0ncyBmcmVlX3RhcmdldCBpbiBmcmVlIFJBTSByZWFw ICpvbmUqIFVNQSB6b25lIHBlcgorICogICAgdGltZSBwZXJpb2QgKDUwMG1zKS4KKyAqIAorICov CisJaWYgKGFyY19pbml0X2RvbmUpIHsKKwkJbm93ID0gZ2V0c2JpbnVwdGltZSgpOworCQlpZiAo KG5vdyAtIGxhc3RfcGFnZWRhZW1vbl93YWtlKSAvIFNCVF8xTVMgPiB6ZnNfYXJjX3dha2V1cF9k ZWxheSkgeworCQkJbGFzdF9wYWdlZGFlbW9uX3dha2UgPSBub3c7CisJCQlhcmNfbm9fd2FrZV9l dmVudCsrOyAgICAvKiBTZXQgYnlwYXNzIGZsYWcgZm9yIEFSQyAqLworCQkJaWYgKCAoICgoaW50 NjRfdCkgZnJlZW1lbSAtIHpmc19hcmNfd2FrZXVwX3BhZ2VyKSA8IDApICYmIChhcmNfd2FybSA9 PSBCX1RSVUUpICkgeworCQkJCWNhbGxfYXJjX2ttZW1fcmVhcCgwKTsJLyogUmVhcCBjYWNoZXMg aWYgd2UncmUgY2xvc2UgKi8KKwkJCQlEVFJBQ0VfUFJPQkUoYXJjX193YWtlX3BhZ2VkYWVtb24p OworCQkJCSh2b2lkKSBwYWdlZGFlbW9uX3dha2V1cCgpOyAgICAvKiBXYWtlIHRoZSBwYWdlciAq LworCQkJfSBlbHNlIHsKKwkJCQlpZiAoICgoaW50NjRfdCkgZnJlZW1lbSAtIHZtX2NudC52X2Zy ZWVfdGFyZ2V0KSA8IDApIHsKKwkJCQkJY2FsbF9hcmNfa21lbV9yZWFwKDEpOwkvKiBSZWFwIG9u ZSBjYWNoZSBpZiBsb3RzIG9mIG1lbW9yeSAqLworCQkJCQlEVFJBQ0VfUFJPQkUyKGFyY19fcmVh cF9vbmUsIGludCwgemZzX2FyY19sYXN0X3NsYWIsIGludCwgU1BBX01BWEJMT0NLU0laRSA+PiBT UEFfTUlOQkxPQ0tTSElGVCk7CisJCQkJfQorCQkJfQorCQl9CisJfSAKKyNlbmRpZiAvKiBXQUtF X1BBR0VSICovCiAKIAkvKgogCSAqIENvb3BlcmF0ZSB3aXRoIHBhZ2VkYWVtb24gd2hlbiBpdCdz IHRpbWUgZm9yIGl0IHRvIHNjYW4KQEAgLTM2MzMsMTIgKzM2ODYsMjIgQEAgZXh0ZXJuIGttZW1f Y2FjaGVfdAkqemlvX2J1Zl9jYWNoZVtdOwogZXh0ZXJuIGttZW1fY2FjaGVfdAkqemlvX2RhdGFf YnVmX2NhY2hlW107CiBleHRlcm4ga21lbV9jYWNoZV90CSpyYW5nZV9zZWdfY2FjaGU7CiAKKy8q CisgKiBQYXNzIGEgZmxhZyB0byB0aGlzIHJvdXRpbmU7IGlmIHplcm8sIHRoZW4gcmVhcCBhbGwu ICBJZiBub3QgdGhlbiByZWFwCisgKiBvbmUgc2xhYiBvbiBhIHJvdGF0aW5nIGJhc2lzLiAgVGhp cyBhbGxvd3MgYSBsb3ctcmF0ZSBjYWxsIHRvIGJlIHVzZWQKKyAqIG9uIGEgcm91dGluZSwgbWFp bnRlbmFuY2UgYmFzaXMgZXZlbiB3aGVuIG5vdCBsb3cgb24gUkFNIHNvIHdlIGRvbid0IGhhdmUK KyAqIGh1Z2UgYW1vdW50cyBvZiBSQU0gb3V0IGluIHVudXNlZCBVTUEgYWxsb2NhdGlvbnMuCisg Ki8KIHN0YXRpYyBfX25vaW5saW5lIHZvaWQKLWFyY19rbWVtX3JlYXBfbm93KHZvaWQpCithcmNf a21lbV9yZWFwX25vdyhmbGFnKQoraW50CWZsYWc7CiB7CiAJc2l6ZV90CQkJaTsKIAlrbWVtX2Nh Y2hlX3QJCSpwcmV2X2NhY2hlID0gTlVMTDsKIAlrbWVtX2NhY2hlX3QJCSpwcmV2X2RhdGFfY2Fj aGUgPSBOVUxMOworCWludAkJCWFyY19jYWNoZV9yZWFwZWQgPSAwOworCWludAkJCWFyY19kYXRh X2NhY2hlX3JlYXBlZCA9IDA7CisJaW50CQkJcmVzZXRfbGFzdF9zbGFiID0gMDsKIAogCURUUkFD RV9QUk9CRShhcmNfX2ttZW1fcmVhcF9zdGFydCk7CiAjaWZkZWYgX0tFUk5FTApAQCAtMzY2MCwx MyArMzcyMywyOCBAQCBzdGF0aWMgX19ub2lubGluZSB2b2lkCiAJZm9yIChpID0gMDsgaSA8IFNQ QV9NQVhCTE9DS1NJWkUgPj4gU1BBX01JTkJMT0NLU0hJRlQ7IGkrKykgewogCQlpZiAoemlvX2J1 Zl9jYWNoZVtpXSAhPSBwcmV2X2NhY2hlKSB7CiAJCQlwcmV2X2NhY2hlID0gemlvX2J1Zl9jYWNo ZVtpXTsKLQkJCWttZW1fY2FjaGVfcmVhcF9ub3coemlvX2J1Zl9jYWNoZVtpXSk7CisJCQlpZiAo KCFmbGFnKSB8fCAoKGkgPiB6ZnNfYXJjX2xhc3Rfc2xhYikgJiYgKCFhcmNfY2FjaGVfcmVhcGVk KSkpIHsKKwkJCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19idWZfY2FjaGVbaV0pOworCQkJCWFy Y19jYWNoZV9yZWFwZWQrKzsKKwkJCX0KIAkJfQogCQlpZiAoemlvX2RhdGFfYnVmX2NhY2hlW2ld ICE9IHByZXZfZGF0YV9jYWNoZSkgewogCQkJcHJldl9kYXRhX2NhY2hlID0gemlvX2RhdGFfYnVm X2NhY2hlW2ldOwotCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6aW9fZGF0YV9idWZfY2FjaGVbaV0p OworCQkJaWYgKCghZmxhZykgfHwgKChpID4gemZzX2FyY19sYXN0X3NsYWIpICYmICghYXJjX2Rh dGFfY2FjaGVfcmVhcGVkKSkpIHsKKwkJCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19kYXRhX2J1 Zl9jYWNoZVtpXSk7CisJCQkJYXJjX2RhdGFfY2FjaGVfcmVhcGVkKys7CisJCQl9CiAJCX0KKwkJ aWYgKGZsYWcgJiYgKCFyZXNldF9sYXN0X3NsYWIpICYmIChhcmNfY2FjaGVfcmVhcGVkIHx8IGFy Y19kYXRhX2NhY2hlX3JlYXBlZCkpIHsKKwkJCXJlc2V0X2xhc3Rfc2xhYiA9IGk7CisJCX0KIAl9 CisJaWYgKHJlc2V0X2xhc3Rfc2xhYikgeworCQl6ZnNfYXJjX2xhc3Rfc2xhYiA9IHJlc2V0X2xh c3Rfc2xhYjsKKwl9CisJaWYgKCghYXJjX2NhY2hlX3JlYXBlZCkgJiYgKCFhcmNfZGF0YV9jYWNo ZV9yZWFwZWQpICYmIChmbGFnKSkgewkvKiBGb3VuZCBub3RoaW5nIHRvIHJlYXAgb24gb25lLXBh c3MgKi8KKwkJemZzX2FyY19sYXN0X3NsYWIgPSAwOwkvKiBSZXNldCAqLworCX0KIAlrbWVtX2Nh Y2hlX3JlYXBfbm93KGJ1Zl9jYWNoZSk7CiAJa21lbV9jYWNoZV9yZWFwX25vdyhoZHJfZnVsbF9j YWNoZSk7CiAJa21lbV9jYWNoZV9yZWFwX25vdyhoZHJfbDJvbmx5X2NhY2hlKTsKQEAgLTM2ODQs NiArMzc2MiwxMiBAQCBzdGF0aWMgX19ub2lubGluZSB2b2lkCiAJRFRSQUNFX1BST0JFKGFyY19f a21lbV9yZWFwX2VuZCk7CiB9CiAKK3ZvaWQJY2FsbF9hcmNfa21lbV9yZWFwKGZsYWcpCitpbnQJ ZmxhZzsKK3sKKwlhcmNfa21lbV9yZWFwX25vdyhmbGFnKTsKK30KKwogLyoKICAqIFRocmVhZHMg Y2FuIGJsb2NrIGluIGFyY19nZXRfZGF0YV9idWYoKSB3YWl0aW5nIGZvciB0aGlzIHRocmVhZCB0 byBldmljdAogICogZW5vdWdoIGRhdGEgYW5kIHNpZ25hbCB0aGVtIHRvIHByb2NlZWQuIFdoZW4g dGhpcyBoYXBwZW5zLCB0aGUgdGhyZWFkcyBpbgpAQCAtMzcyNiw3ICszODEwLDcgQEAgYXJjX3Jl Y2xhaW1fdGhyZWFkKHZvaWQgKmR1bW15IF9fdW51c2VkKQogCQkJICovCiAJCQlncm93dGltZSA9 IGdldGhydGltZSgpICsgU0VDMk5TRUMoYXJjX2dyb3dfcmV0cnkpOwogCi0JCQlhcmNfa21lbV9y ZWFwX25vdygpOworCQkJYXJjX2ttZW1fcmVhcF9ub3coMCk7CiAKIAkJCS8qCiAJCQkgKiBJZiB3 ZSBhcmUgc3RpbGwgbG93IG9uIG1lbW9yeSwgc2hyaW5rIHRoZSBBUkMKQEAgLTU0MzEsNiArNTUx NSwxMCBAQCBzdGF0aWMgZXZlbnRoYW5kbGVyX3RhZyBhcmNfZXZlbnRfbG93bWVtID0gTlVMTDsK IHN0YXRpYyB2b2lkCiBhcmNfbG93bWVtKHZvaWQgKmFyZyBfX3VudXNlZCwgaW50IGhvd3RvIF9f dW51c2VkKQogeworCWlmIChhcmNfbm9fd2FrZV9ldmVudCkgeyAgICAgICAgLyogRG9uJ3QgZG8g aXQgaWYgd2Ugd29rZSB0aGUgcGFnZXIgKi8KKwkJYXJjX25vX3dha2VfZXZlbnQgPSAwOyAgLyog SnVzdCBjbGVhciB0aGUgZmxhZyAqLworCQlyZXR1cm47CisJfQogCiAJbXV0ZXhfZW50ZXIoJmFy Y19yZWNsYWltX2xvY2spOwogCS8qIFhYWDogTWVtb3J5IGRlZmljaXQgc2hvdWxkIGJlIHBhc3Nl ZCBhcyBhcmd1bWVudC4gKi8KQEAgLTU2OTYsNiArNTc4NCw5IEBAIGFyY19pbml0KHZvaWQpCiAJ CXByaW50ZigiICAgICAgICAgICAgIGluIC9ib290L2xvYWRlci5jb25mLlxuIik7CiAJfQogI2Vu ZGlmCisjaWZkZWYJV0FLRV9QQUdFUgorCWFyY19pbml0X2RvbmUrKzsKKyNlbmRpZgkvKiBXQUtF X1BBR0VSICovCiB9CiAKIHZvaWQK 174232 2016-08-30 20:24:09 +0000 2016-08-30 20:24:09 +0000 Dtrace script to go with Second Cut on 11-STABLE wake-pagedaemon text/plain 170 karl IyEvdXNyL3NiaW4vZHRyYWNlIC1zCgpzZHQ6OjphcmMtd2FrZV9wYWdlZGFlbW9uCnsKICAgICAg ICBwcmludGYoIiVZIiwgd2FsbHRpbWVzdGFtcCk7Cn0KCnNkdDo6OmFyYy1yZWFwX29uZQp7CiAg ICAgICAgcHJpbnRmKCIlWSAlZCAlZCIsIHdhbGx0aW1lc3RhbXAsIGFyZzAsIGFyZzEpOwp9Cgo= 174254 2016-08-31 15:00:37 +0000 2016-08-31 15:00:37 +0000 Cleanup of second patch - no functional changes patch-11.0-STABLE-r305005-rev3 text/plain 6092 karl SW5kZXg6IGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMv YXJjLmMJKHJldmlzaW9uIDMwNDk3MSkKKysrIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMv Y29tbW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMjM3LDcgKzIzNywxNyBAQCBp bnQgemZzX2FyY19wX21pbl9zaGlmdCA9IDA7CiBpbnQgemZzX2Rpc2FibGVfZHVwX2V2aWN0aW9u ID0gMDsKIHVpbnQ2NF90IHpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUgPSA4ICogMTAyNDsgLyog OEtCICovCiB1X2ludCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gMDsKK3VfaW50IHpmc19hcmNfd2Fr ZXVwX3BhZ2VyID0gMDsKK3VfaW50IHpmc19hcmNfd2FrZXVwX2RlbGF5ID0gNTAwOworaW50CXpm c19hcmNfbGFzdF9zbGFiID0gMDsKIAorI2RlZmluZQlXQUtFX1BBR0VSCisjaWZkZWYJV0FLRV9Q QUdFUgorI2RlZmluZQlXQUtFX1BBR0VSX0NPTlNUQU5UCTEwIC8gOQkvKiBQYWdlciB3YWtldXAg dGhyZXNob2xkICovCitzdGF0aWMJaW50CWFyY19pbml0X2RvbmUgPSAwOwkvKiBBZnRlciBhcmNf d2FybSBpcyB2YWxpZCAqLworZXh0ZXJuIHZvaWQgcGFnZWRhZW1vbl93YWtldXAodm9pZCk7Cisj ZW5kaWYKKwogLyogQWJzb2x1dGUgbWluIGZvciBhcmMgbWluIC8gbWF4IGlzIDE2TUIuICovCiBz dGF0aWMgdWludDY0X3QgYXJjX2Fic19taW4gPSAxNiA8PCAyMDsKIApAQCAtMjUxLDcgKzI2MSw4 IEBAIHN0YXRpYyB2b2lkCiBhcmNfZnJlZV90YXJnZXRfaW5pdCh2b2lkICp1bnVzZWQgX191bnVz ZWQpCiB7CiAKLQl6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gdm1fcGFnZW91dF93YWtldXBfdGhyZXNo OworCXpmc19hcmNfZnJlZV90YXJnZXQgPSB2bV9wYWdlb3V0X3dha2V1cF90aHJlc2ggKyAodm1f cGFnZW91dF93YWtldXBfdGhyZXNoIC8gMjApOworCXpmc19hcmNfd2FrZXVwX3BhZ2VyID0gdm1f cGFnZW91dF93YWtldXBfdGhyZXNoICogV0FLRV9QQUdFUl9DT05TVEFOVDsKIH0KIFNZU0lOSVQo YXJjX2ZyZWVfdGFyZ2V0X2luaXQsIFNJX1NVQl9LVEhSRUFEX1BBR0UsIFNJX09SREVSX0FOWSwK ICAgICBhcmNfZnJlZV90YXJnZXRfaW5pdCwgTlVMTCk7CkBAIC0zNDc1LDcgKzM0ODYsMTUgQEAg aW50NjRfdCBhcmNfcGFnZXNfcHBfcmVzZXJ2ZSA9IDY0OwogICovCiBpbnQ2NF90IGFyY19zd2Fw ZnNfcmVzZXJ2ZSA9IDY0OwogCisjaWZkZWYJV0FLRV9QQUdFUgogLyoKKyAqIERlY2xhcmUgZmls ZS1sb2NhbCBzdGF0aWMgZm9yIGV2ZW50IHByb2Nlc3NvciBieXBhc3MgYW5kIGZvcndhcmQgZnVu Y3Rpb25zCisgKi8KK3N0YXRpYyB1bnNpZ25lZCBpbnQgYXJjX25vX3dha2VfZXZlbnQgPSAwOwor c3RhdGljIHZvaWQgYXJjX2ttZW1fcmVhcF9ub3coaW50KTsKKyNlbmRpZgorCisvKgogICogUmV0 dXJuIHRoZSBhbW91bnQgb2YgbWVtb3J5IHRoYXQgY2FuIGJlIGNvbnN1bWVkIGJlZm9yZSByZWNs YWltIHdpbGwgYmUKICAqIG5lZWRlZC4gIFBvc2l0aXZlIGlmIHRoZXJlIGlzIHN1ZmZpY2llbnQg ZnJlZSBtZW1vcnksIG5lZ2F0aXZlIGluZGljYXRlcwogICogdGhlIGFtb3VudCBvZiBtZW1vcnkg dGhhdCBuZWVkcyB0byBiZSBmcmVlZCB1cC4KQEAgLTM0ODgsNiArMzUwNywxMSBAQCBhcmNfYXZh aWxhYmxlX21lbW9yeSh2b2lkKQogCWZyZWVfbWVtb3J5X3JlYXNvbl90IHIgPSBGTVJfVU5LTk9X TjsKIAogI2lmZGVmIF9LRVJORUwKKyNpZmRlZiBXQUtFX1BBR0VSCisJc2JpbnRpbWVfdCBub3c7 CisJc3RhdGljIHNiaW50aW1lX3QgbGFzdF9wYWdlZGFlbW9uX3dha2UgPSAwOworI2VuZGlmCS8q IFdBS0VfUEFHRVIgKi8KKwogCWlmIChuZWVkZnJlZSA+IDApIHsKIAkJbiA9IFBBR0VTSVpFICog KC1uZWVkZnJlZSk7CiAJCWlmIChuIDwgbG93ZXN0KSB7CkBAIC0zNDk1LDYgKzM1MTksMzcgQEAg YXJjX2F2YWlsYWJsZV9tZW1vcnkodm9pZCkKIAkJCXIgPSBGTVJfTkVFREZSRUU7CiAJCX0KIAl9 CisjaWZkZWYgV0FLRV9QQUdFUgorLyoKKyAqIFdoZW4gYXJjIGlzIGluaXRpYWxpemVkLCBwZXJm b3JtIHRoZSBmb2xsb3dpbmc6CisgKgorICogMS4gSWYgd2UgYXJlIGluIHRoZSAibWVtb3J5IGlz IGxvdyBlbm91Z2ggdG8gd2FrZSB0aGUgcGFnZXIiIHpvbmUsCisgKiAgICByZWFwIHRoZSBrZXJu ZWwgVU1BIGNhY2hlcyBvbmNlIHBlciB3YWtldXBfZGVsYXkgcGVyaW9kIDUwMG1zIGRlZmF1bHQp CisgKiAgICBBTkQgd2FrZSB0aGUgcGFnZXIgdXAgKHNvIGl0IGNhbiBkZW1vdGUgcGFnZXMgZnJv bSBpbmFjdGl2ZSB0byBjYWNoZSB0bworICogICAgdWx0aW1hdGVseSB0aGUgZnJlZSBsaXN0LikK KyAqCisgKiAyLiBJZiB3ZSdyZSBiZWxvdyBWTSdzIGZyZWVfdGFyZ2V0IGluIGZyZWUgUkFNIHJl YXAgKm9uZSogVU1BIHpvbmUgcGVyCisgKiAgICB0aW1lIHBlcmlvZCAoNTAwbXMpLgorICogCisg Ki8KKwlpZiAoYXJjX2luaXRfZG9uZSkgeworCQlub3cgPSBnZXRzYmludXB0aW1lKCk7CisJCWlm ICgobm93IC0gbGFzdF9wYWdlZGFlbW9uX3dha2UpIC8gU0JUXzFNUyA+IHpmc19hcmNfd2FrZXVw X2RlbGF5KSB7CisJCQlsYXN0X3BhZ2VkYWVtb25fd2FrZSA9IG5vdzsKKwkJCWFyY19ub193YWtl X2V2ZW50Kys7ICAgIC8qIFNldCBieXBhc3MgZmxhZyBmb3IgQVJDICovCisJCQlpZiAoICggKChp bnQ2NF90KSBmcmVlbWVtIC0gemZzX2FyY193YWtldXBfcGFnZXIpIDwgMCkgJiYgKGFyY193YXJt ID09IEJfVFJVRSkgKSB7CisJCQkJYXJjX2ttZW1fcmVhcF9ub3coMCk7CS8qIFJlYXAgY2FjaGVz IGlmIHdlJ3JlIGNsb3NlICovCisJCQkJRFRSQUNFX1BST0JFKGFyY19fd2FrZV9wYWdlZGFlbW9u KTsKKwkJCQkodm9pZCkgcGFnZWRhZW1vbl93YWtldXAoKTsgICAgLyogV2FrZSB0aGUgcGFnZXIg Ki8KKwkJCX0gZWxzZSB7CisJCQkJaWYgKCAoKGludDY0X3QpIGZyZWVtZW0gLSB2bV9jbnQudl9m cmVlX3RhcmdldCkgPCAwKSB7CisJCQkJCWFyY19rbWVtX3JlYXBfbm93KDEpOwkvKiBSZWFwIG9u ZSBjYWNoZSBpZiBsb3RzIG9mIG1lbW9yeSAqLworCQkJCQlEVFJBQ0VfUFJPQkUyKGFyY19fcmVh cF9vbmUsIGludCwgemZzX2FyY19sYXN0X3NsYWIsIGludCwgU1BBX01BWEJMT0NLU0laRSA+PiBT UEFfTUlOQkxPQ0tTSElGVCk7CisJCQkJfQorCQkJfQorCQl9CisJfSAKKyNlbmRpZiAvKiBXQUtF X1BBR0VSICovCiAKIAkvKgogCSAqIENvb3BlcmF0ZSB3aXRoIHBhZ2VkYWVtb24gd2hlbiBpdCdz IHRpbWUgZm9yIGl0IHRvIHNjYW4KQEAgLTM2MzMsMTIgKzM2ODgsMjIgQEAgZXh0ZXJuIGttZW1f Y2FjaGVfdAkqemlvX2J1Zl9jYWNoZVtdOwogZXh0ZXJuIGttZW1fY2FjaGVfdAkqemlvX2RhdGFf YnVmX2NhY2hlW107CiBleHRlcm4ga21lbV9jYWNoZV90CSpyYW5nZV9zZWdfY2FjaGU7CiAKKy8q CisgKiBQYXNzIGEgZmxhZyB0byB0aGlzIHJvdXRpbmU7IGlmIHplcm8sIHRoZW4gcmVhcCBhbGwu ICBJZiBub3QgdGhlbiByZWFwCisgKiBvbmUgc2xhYiBvbiBhIHJvdGF0aW5nIGJhc2lzLiAgVGhp cyBhbGxvd3MgYSBsb3ctcmF0ZSBjYWxsIHRvIGJlIHVzZWQKKyAqIG9uIGEgcm91dGluZSwgbWFp bnRlbmFuY2UgYmFzaXMgZXZlbiB3aGVuIG5vdCB0ZXJyaWJseSBsb3cgb24gUkFNIHNvIAorICog d2UgZG9uJ3QgaGF2ZSBodWdlIGFtb3VudHMgb2YgUkFNIG91dCBpbiB1bnVzZWQgVU1BIGFsbG9j YXRpb25zLgorICovCiBzdGF0aWMgX19ub2lubGluZSB2b2lkCi1hcmNfa21lbV9yZWFwX25vdyh2 b2lkKQorYXJjX2ttZW1fcmVhcF9ub3coZmxhZykKK2ludAlmbGFnOwogewogCXNpemVfdAkJCWk7 CiAJa21lbV9jYWNoZV90CQkqcHJldl9jYWNoZSA9IE5VTEw7CiAJa21lbV9jYWNoZV90CQkqcHJl dl9kYXRhX2NhY2hlID0gTlVMTDsKKwlpbnQJCQlhcmNfY2FjaGVfcmVhcGVkID0gMDsKKwlpbnQJ CQlhcmNfZGF0YV9jYWNoZV9yZWFwZWQgPSAwOworCWludAkJCXJlc2V0X2xhc3Rfc2xhYiA9IDA7 CiAKIAlEVFJBQ0VfUFJPQkUoYXJjX19rbWVtX3JlYXBfc3RhcnQpOwogI2lmZGVmIF9LRVJORUwK QEAgLTM2NjAsMTMgKzM3MjUsMjggQEAgc3RhdGljIF9fbm9pbmxpbmUgdm9pZAogCWZvciAoaSA9 IDA7IGkgPCBTUEFfTUFYQkxPQ0tTSVpFID4+IFNQQV9NSU5CTE9DS1NISUZUOyBpKyspIHsKIAkJ aWYgKHppb19idWZfY2FjaGVbaV0gIT0gcHJldl9jYWNoZSkgewogCQkJcHJldl9jYWNoZSA9IHpp b19idWZfY2FjaGVbaV07Ci0JCQlrbWVtX2NhY2hlX3JlYXBfbm93KHppb19idWZfY2FjaGVbaV0p OworCQkJaWYgKCghZmxhZykgfHwgKChpID4gemZzX2FyY19sYXN0X3NsYWIpICYmICghYXJjX2Nh Y2hlX3JlYXBlZCkpKSB7CisJCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6aW9fYnVmX2NhY2hlW2ld KTsKKwkJCQlhcmNfY2FjaGVfcmVhcGVkKys7CisJCQl9CiAJCX0KIAkJaWYgKHppb19kYXRhX2J1 Zl9jYWNoZVtpXSAhPSBwcmV2X2RhdGFfY2FjaGUpIHsKIAkJCXByZXZfZGF0YV9jYWNoZSA9IHpp b19kYXRhX2J1Zl9jYWNoZVtpXTsKLQkJCWttZW1fY2FjaGVfcmVhcF9ub3coemlvX2RhdGFfYnVm X2NhY2hlW2ldKTsKKwkJCWlmICgoIWZsYWcpIHx8ICgoaSA+IHpmc19hcmNfbGFzdF9zbGFiKSAm JiAoIWFyY19kYXRhX2NhY2hlX3JlYXBlZCkpKSB7CisJCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6 aW9fZGF0YV9idWZfY2FjaGVbaV0pOworCQkJCWFyY19kYXRhX2NhY2hlX3JlYXBlZCsrOworCQkJ fQogCQl9CisJCWlmIChmbGFnICYmICghcmVzZXRfbGFzdF9zbGFiKSAmJiAoYXJjX2NhY2hlX3Jl YXBlZCB8fCBhcmNfZGF0YV9jYWNoZV9yZWFwZWQpKSB7CisJCQlyZXNldF9sYXN0X3NsYWIgPSBp OworCQl9CiAJfQorCWlmIChyZXNldF9sYXN0X3NsYWIpIHsKKwkJemZzX2FyY19sYXN0X3NsYWIg PSByZXNldF9sYXN0X3NsYWI7CisJfQorCWlmICgoIWFyY19jYWNoZV9yZWFwZWQpICYmICghYXJj X2RhdGFfY2FjaGVfcmVhcGVkKSAmJiAoZmxhZykpIHsJLyogRm91bmQgbm90aGluZyB0byByZWFw IG9uIG9uZS1wYXNzICovCisJCXpmc19hcmNfbGFzdF9zbGFiID0gMDsJLyogUmVzZXQgKi8KKwl9 CiAJa21lbV9jYWNoZV9yZWFwX25vdyhidWZfY2FjaGUpOwogCWttZW1fY2FjaGVfcmVhcF9ub3co aGRyX2Z1bGxfY2FjaGUpOwogCWttZW1fY2FjaGVfcmVhcF9ub3coaGRyX2wyb25seV9jYWNoZSk7 CkBAIC0zNzI2LDcgKzM4MDYsNyBAQCBhcmNfcmVjbGFpbV90aHJlYWQodm9pZCAqZHVtbXkgX191 bnVzZWQpCiAJCQkgKi8KIAkJCWdyb3d0aW1lID0gZ2V0aHJ0aW1lKCkgKyBTRUMyTlNFQyhhcmNf Z3Jvd19yZXRyeSk7CiAKLQkJCWFyY19rbWVtX3JlYXBfbm93KCk7CisJCQlhcmNfa21lbV9yZWFw X25vdygwKTsKIAogCQkJLyoKIAkJCSAqIElmIHdlIGFyZSBzdGlsbCBsb3cgb24gbWVtb3J5LCBz aHJpbmsgdGhlIEFSQwpAQCAtNTQzMSw2ICs1NTExLDEwIEBAIHN0YXRpYyBldmVudGhhbmRsZXJf dGFnIGFyY19ldmVudF9sb3dtZW0gPSBOVUxMOwogc3RhdGljIHZvaWQKIGFyY19sb3dtZW0odm9p ZCAqYXJnIF9fdW51c2VkLCBpbnQgaG93dG8gX191bnVzZWQpCiB7CisJaWYgKGFyY19ub193YWtl X2V2ZW50KSB7ICAgICAgICAvKiBEb24ndCBkbyBpdCBpZiB3ZSB3b2tlIHRoZSBwYWdlciAqLwor CQlhcmNfbm9fd2FrZV9ldmVudCA9IDA7ICAvKiBKdXN0IGNsZWFyIHRoZSBmbGFnICovCisJCXJl dHVybjsKKwl9CiAKIAltdXRleF9lbnRlcigmYXJjX3JlY2xhaW1fbG9jayk7CiAJLyogWFhYOiBN ZW1vcnkgZGVmaWNpdCBzaG91bGQgYmUgcGFzc2VkIGFzIGFyZ3VtZW50LiAqLwpAQCAtNTY5Niw2 ICs1NzgwLDkgQEAgYXJjX2luaXQodm9pZCkKIAkJcHJpbnRmKCIgICAgICAgICAgICAgaW4gL2Jv b3QvbG9hZGVyLmNvbmYuXG4iKTsKIAl9CiAjZW5kaWYKKyNpZmRlZglXQUtFX1BBR0VSCisJYXJj X2luaXRfZG9uZSsrOworI2VuZGlmCS8qIFdBS0VfUEFHRVIgKi8KIH0KIAogdm9pZAo= 186818 2017-09-30 17:33:02 +0000 2017-09-30 17:33:02 +0000 Patch against r324056 (11.1-STABLE) w/Phabricator D7538 improvements patch-D7538-11-1-r324056 text/plain 11322 karl SW5kZXg6IGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMvY29tbW9uL2ZzL3pmcy9hcmMuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBjZGRsL2NvbnRyaWIvb3BlbnNvbGFyaXMvdXRzL2NvbW1vbi9mcy96ZnMv YXJjLmMJKHJldmlzaW9uIDMyNDA1NikKKysrIGNkZGwvY29udHJpYi9vcGVuc29sYXJpcy91dHMv Y29tbW9uL2ZzL3pmcy9hcmMuYwkod29ya2luZyBjb3B5KQpAQCAtMzYyLDcgKzM2MiwxNiBAQCBp bnQgemZzX2FyY19ub19ncm93X3NoaWZ0ID0gMDsKIGludCB6ZnNfYXJjX3BfbWluX3NoaWZ0ID0g MDsKIHVpbnQ2NF90IHpmc19hcmNfYXZlcmFnZV9ibG9ja3NpemUgPSA4ICogMTAyNDsgLyogOEtC ICovCiB1X2ludCB6ZnNfYXJjX2ZyZWVfdGFyZ2V0ID0gMDsKK3VfaW50IHpmc19hcmNfd2FrZXVw X3BhZ2VyID0gMDsKK3VfaW50IHpmc19hcmNfd2FrZXVwX2RlbGF5ID0gNTAwOwkvKiA1MDBtcyBi ZXR3ZWVuIHBhZ2VyIHdha2V1cHMgbWluICovCiAKKyNkZWZpbmUJV0FLRV9QQUdFUgorI2lmZGVm CVdBS0VfUEFHRVIKKyNkZWZpbmUJRlJFRV9UQVJHRVRfQ09OU1RBTlQJMTAgLyA4ICAvKiBUYXJn ZXQgYWJvdmUgcGFnZW91dF93YWtldXBfdGhyZXNoICovCitzdGF0aWMgaW50CWFyY19pbml0X2Rv bmUgPSAwOyAgICAgIC8qIEFmdGVyIGFyY193YXJtIGlzIHZhbGlkICovCitleHRlcm4gdm9pZAlw YWdlZGFlbW9uX3dha2V1cCh2b2lkKTsKKyNlbmRpZgorCiAvKiBBYnNvbHV0ZSBtaW4gZm9yIGFy YyBtaW4gLyBtYXggaXMgMTZNQi4gKi8KIHN0YXRpYyB1aW50NjRfdCBhcmNfYWJzX21pbiA9IDE2 IDw8IDIwOwogCkBAIC0zNzksNyArMzg4LDkgQEAgc3RhdGljIHZvaWQKIGFyY19mcmVlX3Rhcmdl dF9pbml0KHZvaWQgKnVudXNlZCBfX3VudXNlZCkKIHsKIAotCXpmc19hcmNfZnJlZV90YXJnZXQg PSB2bV9wYWdlb3V0X3dha2V1cF90aHJlc2g7CisJemZzX2FyY19mcmVlX3RhcmdldCA9IHZtX3Bh Z2VvdXRfd2FrZXVwX3RocmVzaCArICh2bV9wYWdlb3V0X3dha2V1cF90aHJlc2ggLyA1KTsKKwl6 ZnNfYXJjX3dha2V1cF9wYWdlciA9IHZtX3BhZ2VvdXRfd2FrZXVwX3RocmVzaCArICgodm1fY250 LnZfZnJlZV90YXJnZXQgLSB2bV9wYWdlb3V0X3dha2V1cF90aHJlc2gpIC8gMik7CQorCiB9CiBT WVNJTklUKGFyY19mcmVlX3RhcmdldF9pbml0LCBTSV9TVUJfS1RIUkVBRF9QQUdFLCBTSV9PUkRF Ul9BTlksCiAgICAgYXJjX2ZyZWVfdGFyZ2V0X2luaXQsIE5VTEwpOwpAQCAtNDIyNSwxMyArNDIz NiwyMSBAQCBpbnQ2NF90IGFyY19wYWdlc19wcF9yZXNlcnZlID0gNjQ7CiAgKi8KIGludDY0X3Qg YXJjX3N3YXBmc19yZXNlcnZlID0gNjQ7CiAKK3R5cGVkZWYgZW51bSBmcmVlX21lbW9yeV9tZWFz dXJlX3QgeworCUZNTV9FWENMVURFX1pPTkVfQ0FDSEUsCisJRk1NX0lOQ0xVREVfWk9ORV9DQUNI RQorfSBmcmVlX21lbW9yeV9tZWFzdXJlX3Q7CisKIC8qCiAgKiBSZXR1cm4gdGhlIGFtb3VudCBv ZiBtZW1vcnkgdGhhdCBjYW4gYmUgY29uc3VtZWQgYmVmb3JlIHJlY2xhaW0gd2lsbCBiZQogICog bmVlZGVkLiAgUG9zaXRpdmUgaWYgdGhlcmUgaXMgc3VmZmljaWVudCBmcmVlIG1lbW9yeSwgbmVn YXRpdmUgaW5kaWNhdGVzCiAgKiB0aGUgYW1vdW50IG9mIG1lbW9yeSB0aGF0IG5lZWRzIHRvIGJl IGZyZWVkIHVwLgogICovCisKK3N0YXRpYyBpbnQ2NF90IGFyY19jaGVja191bWFfY2FjaGUoaW50 NjRfdCBsb3dlc3QpOworCiBzdGF0aWMgaW50NjRfdAotYXJjX2F2YWlsYWJsZV9tZW1vcnkodm9p ZCkKK2FyY19hdmFpbGFibGVfbWVtb3J5KGZyZWVfbWVtb3J5X21lYXN1cmVfdCB6b25lX21lYXN1 cmUpCiB7CiAJaW50NjRfdCBsb3dlc3QgPSBJTlQ2NF9NQVg7CiAJaW50NjRfdCBuOwpAQCAtNDIz OCw3ICs0MjU3LDE2IEBAIHN0YXRpYyBpbnQ2NF90CiAJZnJlZV9tZW1vcnlfcmVhc29uX3QgciA9 IEZNUl9VTktOT1dOOwogCiAjaWZkZWYgX0tFUk5FTAorI2lmZGVmCVdBS0VfUEFHRVIKKwlzYmlu dGltZV90IG5vdzsKKwlzdGF0aWMgc2JpbnRpbWVfdCBsYXN0X3BhZ2VkYWVtb25fd2FrZSA9IDA7 CisjZW5kaWYJLyogV0FLRV9QQUdFUiAqLworCiAJaWYgKG5lZWRmcmVlID4gMCkgeworCQluID0g KGludDY0X3Qpdm1fY250LnZfZnJlZV90YXJnZXQgLSAoaW50NjRfdCl2bV9jbnQudl9mcmVlX2Nv dW50OworCQluZWVkZnJlZSA9IG4gPiAwID8gbiA6IDA7CisJfQorCWlmIChuZWVkZnJlZSA+IDAp IHsKIAkJbiA9IFBBR0VTSVpFICogKC1uZWVkZnJlZSk7CiAJCWlmIChuIDwgbG93ZXN0KSB7CiAJ CQlsb3dlc3QgPSBuOwpAQCAtNDI0NiwxMSArNDI3NCw0MSBAQCBzdGF0aWMgaW50NjRfdAogCQl9 CiAJfQogCisjaWZkZWYJV0FLRV9QQUdFUgorLyoKKyAqIFdoZW4gYXJjIGlzIGluaXRpYWxpemVk IHRoZW4gY2hlY2sgdG8gc2VlIGlmIHdlJ3JlIGluIGEgVk0gIndhcm1pbmciIHpvbmUsCisgKiBh bmQgaWYgc28gdGhlbiB3YWtlIHRoZSBwYWdlciAtLSB0aGUgaW50ZW50IGJlaW5nIHRvIGRlbW90 ZSBpbmFjdGl2ZSBwYWdlcy4KKyAqLworCWlmIChhcmNfaW5pdF9kb25lKSB7CisJCW5vdyA9IGdl dHNiaW51cHRpbWUoKTsKKwkJaWYgKChub3cgLSBsYXN0X3BhZ2VkYWVtb25fd2FrZSkgLyBTQlRf MU1TID4gemZzX2FyY193YWtldXBfZGVsYXkpIHsKKwkJCWxhc3RfcGFnZWRhZW1vbl93YWtlID0g bm93OworI2lmZGVmCVJFQVBfQVJDCisJCQlhcmNfbm9fd2FrZV9ldmVudCsrOyAgICAvKiBTZXQg YnlwYXNzIGZsYWcgZm9yIEFSQyAqLworI2VuZGlmCisJCQlpZiAoICggKChpbnQ2NF90KSBmcmVl bWVtIC0gemZzX2FyY193YWtldXBfcGFnZXIpIDwgMCkgJiYgKGFyY193YXJtID09IEJfVFJVRSkg KSB7CisjaWZkZWYJUkVBUF9BUkMKKwkJCQlhcmNfa21lbV9yZWFwX25vdygwKTsgICAvKiBSZWFw IGNhY2hlcyBpZiB3ZSdyZSBjbG9zZSAqLworI2VuZGlmCisJCQkJRFRSQUNFX1BST0JFKGFyY19f d2FrZV9wYWdlZGFlbW9uKTsKKwkJCQkodm9pZCkgcGFnZWRhZW1vbl93YWtldXAoKTsgICAgLyog V2FrZSB0aGUgcGFnZXIgKi8KKyNpZmRlZglSRUFQX0FSQworCQkJfSBlbHNlIHsKKwkJCQlpZiAo ICgoaW50NjRfdCkgZnJlZW1lbSAtIHZtX2NudC52X2ZyZWVfdGFyZ2V0KSA8IDApIHsKKwkJCQkJ YXJjX2ttZW1fcmVhcF9ub3coMSk7ICAgLyogUmVhcCBvbmUgY2FjaGUgaWYgbG90cyBvZiBtZW1v cnkgKi8KKwkJCQkJRFRSQUNFX1BST0JFMihhcmNfX3JlYXBfb25lLCBpbnQsIHpmc19hcmNfbGFz dF9zbGFiLCBpbnQsIFNQQV9NQVhCTE9DS1NJWkUgPj4gU1BBX01JTkJMT0NLU0hJRlQpOworCQkJ CX0KKyNlbmRpZgorCQkJfQorCQl9CisJfQorCisjZW5kaWYJLyogV0FLRV9QQUdFUiAqLwogCS8q CiAJICogQ29vcGVyYXRlIHdpdGggcGFnZWRhZW1vbiB3aGVuIGl0J3MgdGltZSBmb3IgaXQgdG8g c2NhbgogCSAqIGFuZCByZWNsYWltIHNvbWUgcGFnZXMuCiAJICovCi0JbiA9IFBBR0VTSVpFICog KChpbnQ2NF90KWZyZWVtZW0gLSB6ZnNfYXJjX2ZyZWVfdGFyZ2V0KTsKKwluID0gUEFHRVNJWkUg KiAoKGludDY0X3QpZnJlZW1lbSAtIChpbnQ2NF90KXpmc19hcmNfZnJlZV90YXJnZXQgLSAoaW50 NjRfdCl2bV9jbnQudl9mcmVlX3Jlc2VydmVkKTsKIAlpZiAobiA8IGxvd2VzdCkgewogCQlsb3dl c3QgPSBuOwogCQlyID0gRk1SX0xPVFNGUkVFOwpAQCAtNDM1NSw2ICs0NDEzLDE2IEBAIHN0YXRp YyBpbnQ2NF90CiAJCX0KIAl9CiAKKwkvKiBTb21lIG1lbW9yeSBjYW4gYmUgaW4gem9uZSBjYWNo ZSBlbGVtZW50cywgZm9yIHRoaXMgY2FzZQorCSAqIEFSQyBjYWNoZSBub3QgdW5kZXIgbWVtb3J5 IHByZXNzdXJlIGFuZCBjYW4gcmlzZS4KKwkgKiB6b25lX21lYXN1cmUgPT0gRk1NX0lOQ0xVREVf Wk9ORV9DQUNIRSBmbGFnZWQgdGhpcworCSAqLworCWlmIChsb3dlc3QgPCAwICYmIHpvbmVfbWVh c3VyZSA9PSBGTU1fSU5DTFVERV9aT05FX0NBQ0hFKSB7CisJCWxvd2VzdCA9IGFyY19jaGVja191 bWFfY2FjaGUobG93ZXN0KTsKKwkJaWYgKGxvd2VzdCA+PSAwKQorCQkJCXIgPSBGTVJfVU5LTk9X TjsKKwl9CisKICNlbHNlCS8qIF9LRVJORUwgKi8KIAkvKiBFdmVyeSAxMDAgY2FsbHMsIGZyZWUg YSBzbWFsbCBhbW91bnQgKi8KIAlpZiAoc3BhX2dldF9yYW5kb20oMTAwKSA9PSAwKQpAQCAtNDM3 Niw3ICs0NDQ0LDcgQEAgc3RhdGljIGludDY0X3QKIHN0YXRpYyBib29sZWFuX3QKIGFyY19yZWNs YWltX25lZWRlZCh2b2lkKQogewotCXJldHVybiAoYXJjX2F2YWlsYWJsZV9tZW1vcnkoKSA8IDAp OworCXJldHVybiAoYXJjX2F2YWlsYWJsZV9tZW1vcnkoRk1NX0lOQ0xVREVfWk9ORV9DQUNIRSkg PCAwKTsKIH0KIAogZXh0ZXJuIGttZW1fY2FjaGVfdAkqemlvX2J1Zl9jYWNoZVtdOwpAQCAtNDQz Niw2ICs0NTA0LDY2IEBAIGFyY19rbWVtX3JlYXBfbm93KHZvaWQpCiAJRFRSQUNFX1BST0JFKGFy Y19fa21lbV9yZWFwX2VuZCk7CiB9CiAKK2ludCBzeXNjdGxfZHJhaW5fY2FjaGUgPSAxOworU1lT Q1RMX0lOVChfdmZzX3pmcywgT0lEX0FVVE8sIGRyYWluX3VtYV9jYWNoZSwgQ1RMRkxBR19SVywg JnN5c2N0bF9kcmFpbl9jYWNoZSwgMCwgImRyYWluIHBlci1DUFUgVU1BIGNhY2hlIik7CisKKwor I2lmZGVmIF9LRVJORUwKK3N0YXRpYyBpbnQ2NF90CithcmNfY2hlY2tfdW1hX2NhY2hlKGludDY0 X3QgbG93ZXN0KQoreworCWludAkJCWl0ZXIgPSA0OworCWludAkJCXN0ZXAgPSAxIDw8IChTUEFf TUFYQkxPQ0tTSElGVCAtIFNQQV9NSU5CTE9DS1NISUZUIC0gMyk7CisJaW50CQkJbiA9IChTUEFf TUFYQkxPQ0tTSVpFID4+IFNQQV9NSU5CTE9DS1NISUZUKSAtIDE7CisKKwl3aGlsZSAobiA+PSAw KSB7CisJCWxvd2VzdCArPSB1bWFfem9uZV9nZXRfZnJlZV9zaXplKHppb19kYXRhX2J1Zl9jYWNo ZVtuXS0+a2Nfem9uZSk7CisJCWlmIChsb3dlc3QgPj0gMCkKKwkJCXJldHVybiBsb3dlc3Q7CisJ CW4gLT0gc3RlcDsKKwkJaWYoLS1pdGVyID09IDApIHsKKwkJCWlmIChzdGVwID4gMSkgc3RlcCA+ Pj0gMTsKKwkJCWl0ZXIgPSA0OworCQl9CisJfQorCXJldHVybiBsb3dlc3Q7Cit9CisjZW5kaWYK Kworc3RhdGljIHZvaWQKK2FyY19kcmFpbl91bWFfY2FjaGUodWludDY0X3QgdGFyZ2V0KQorewor CWludAkJCWl0ZXIgPSA0OworCWludAkJCXN0ZXAgPSAxIDw8IChTUEFfTUFYQkxPQ0tTSElGVCAt IFNQQV9NSU5CTE9DS1NISUZUIC0gMyk7CisJaW50CQkJbiA9IChTUEFfTUFYQkxPQ0tTSVpFID4+ IFNQQV9NSU5CTE9DS1NISUZUKSAtIDE7CisJc2l6ZV90CQkJZnJlZV9zaXplOworCisJRFRSQUNF X1BST0JFMihhcmNfX2RyYWluX3VtYV9jYWNoZV9zdGFydCwgdWludDY0X3QsIHRhcmdldCwgdWlu dDY0X3QsICh1aW50NjRfdCl2bV9jbnQudl9mcmVlX2NvdW50ICogUEFHRVNJWkUpOworI2lmZGVm IF9LRVJORUwKKwlmcmVlX3NpemUgPSAodWludDY0X3Qpdm1fY250LnZfZnJlZV9jb3VudCAqIFBB R0VTSVpFOworCWlmICh0YXJnZXQgPD0gZnJlZV9zaXplKQorCQlyZXR1cm47CisJd2hpbGUgKG4g Pj0gMCkgeworCQlmcmVlX3NpemUgPSB1bWFfem9uZV9nZXRfZnJlZV9zaXplKHppb19kYXRhX2J1 Zl9jYWNoZVtuXS0+a2Nfem9uZSk7CisJCWlmIChmcmVlX3NpemUpIHsKKwkJCWlmIChzeXNjdGxf ZHJhaW5fY2FjaGUpCisJCQkJdW1hX3JlY2xhaW1fem9uZV9jYWNoZSh6aW9fZGF0YV9idWZfY2Fj aGVbbl0tPmtjX3pvbmUpOworCQkJa21lbV9jYWNoZV9yZWFwX25vdyh6aW9fZGF0YV9idWZfY2Fj aGVbbl0pOworCQkJRFRSQUNFX1BST0JFMyhhcmNfX2RyYWluX3VtYV9jYWNoZV96b25lLCBjaGFy ICosIHppb19kYXRhX2J1Zl9jYWNoZVtuXS0+a2NfbmFtZSwgc2l6ZV90LCBmcmVlX3NpemUsIHVp bnQ2NF90LCAodWludDY0X3Qpdm1fY250LnZfZnJlZV9jb3VudCAqIFBBR0VTSVpFKTsKKwkJCWZy ZWVfc2l6ZSA9ICh1aW50NjRfdCl2bV9jbnQudl9mcmVlX2NvdW50ICogUEFHRVNJWkU7CisJCQlp ZiAodGFyZ2V0IDw9IGZyZWVfc2l6ZSkKKwkJCQlicmVhazsKKwkJfQorCQluIC09IHN0ZXA7CisJ CWlmKC0taXRlciA9PSAwKSB7CisJCQlpZiAoc3RlcCA+IDEpIHN0ZXAgPj49IDE7CisJCQlpdGVy ID0gNDsKKwkJfQorCX0KKyNlbmRpZgorCURUUkFDRV9QUk9CRShhcmNfX2RyYWluX3VtYV9jYWNo ZV9lbmQpOworfQorCiAvKgogICogVGhyZWFkcyBjYW4gYmxvY2sgaW4gYXJjX2dldF9kYXRhX2lt cGwoKSB3YWl0aW5nIGZvciB0aGlzIHRocmVhZCB0byBldmljdAogICogZW5vdWdoIGRhdGEgYW5k IHNpZ25hbCB0aGVtIHRvIHByb2NlZWQuIFdoZW4gdGhpcyBoYXBwZW5zLCB0aGUgdGhyZWFkcyBp bgpAQCAtNDQ4Nyw3ICs0NjE1LDggQEAgYXJjX3JlY2xhaW1fdGhyZWFkKHZvaWQgKmR1bW15IF9f dW51c2VkKQogCQkgKi8KIAkJZXZpY3RlZCA9IGFyY19hZGp1c3QoKTsKIAotCQlpbnQ2NF90IGZy ZWVfbWVtb3J5ID0gYXJjX2F2YWlsYWJsZV9tZW1vcnkoKTsKKwkJaW50NjRfdCBmcmVlX21lbW9y eSA9IGFyY19hdmFpbGFibGVfbWVtb3J5KEZNTV9FWENMVURFX1pPTkVfQ0FDSEUpOworCQlEVFJB Q0VfUFJPQkUyKGFyY19fcmVjbGFpbV9hZGosIHVpbnQ2NF90LCBldmljdGVkLCBpbnQ2NF90LCBm cmVlX21lbW9yeSk7CiAJCWlmIChmcmVlX21lbW9yeSA8IDApIHsKIAogCQkJYXJjX25vX2dyb3cg PSBCX1RSVUU7CkBAIC00NDk5LDIxICs0NjI4LDM1IEBAIGFyY19yZWNsYWltX3RocmVhZCh2b2lk ICpkdW1teSBfX3VudXNlZCkKIAkJCSAqLwogCQkJZ3Jvd3RpbWUgPSBnZXRocnRpbWUoKSArIFNF QzJOU0VDKGFyY19ncm93X3JldHJ5KTsKIAorI2lmZGVmIF9LRVJORUwKKwkJCWlmIChhcmNfY2hl Y2tfdW1hX2NhY2hlKGZyZWVfbWVtb3J5KSA+PSAwKQorCQkJCWFyY19kcmFpbl91bWFfY2FjaGUo KHVpbnQ2NF90KWZyZWVtZW0gKiBQQUdFU0laRSAtIGZyZWVfbWVtb3J5KTsKKyNlbHNlCiAJCQlh cmNfa21lbV9yZWFwX25vdygpOwotCisjZW5kaWYKKwkJCQogCQkJLyoKIAkJCSAqIElmIHdlIGFy ZSBzdGlsbCBsb3cgb24gbWVtb3J5LCBzaHJpbmsgdGhlIEFSQwogCQkJICogc28gdGhhdCB3ZSBo YXZlIGFyY19zaHJpbmtfbWluIGZyZWUgc3BhY2UuCiAJCQkgKi8KLQkJCWZyZWVfbWVtb3J5ID0g YXJjX2F2YWlsYWJsZV9tZW1vcnkoKTsKKwkJCWZyZWVfbWVtb3J5ID0gYXJjX2F2YWlsYWJsZV9t ZW1vcnkoRk1NX0VYQ0xVREVfWk9ORV9DQUNIRSk7CiAKIAkJCWludDY0X3QgdG9fZnJlZSA9CiAJ CQkgICAgKGFyY19jID4+IGFyY19zaHJpbmtfc2hpZnQpIC0gZnJlZV9tZW1vcnk7CisJCQlEVFJB Q0VfUFJPQkUzKGFyY19fcmVjbGFpbV90c3QsIGludDY0X3QsIHRvX2ZyZWUsIGludDY0X3QsIGZy ZWVfbWVtb3J5LCBsb25nLCBuZWVkZnJlZSk7CiAJCQlpZiAodG9fZnJlZSA+IDApIHsKICNpZmRl ZiBfS0VSTkVMCiAJCQkJdG9fZnJlZSA9IE1BWCh0b19mcmVlLCBwdG9iKG5lZWRmcmVlKSk7CisJ CQkJdWludDY0X3QgZnJlZV90YXJnZXQgPSAKKwkJCQkJKHVpbnQ2NF90KWZyZWVtZW0gKiBQQUdF U0laRSAtIGZyZWVfbWVtb3J5OwogI2VuZGlmCiAJCQkJYXJjX3Nocmluayh0b19mcmVlKTsKKyNp ZmRlZiBfS0VSTkVMCisJCQkJYXJjX2RyYWluX3VtYV9jYWNoZShmcmVlX3RhcmdldCk7CisjZWxz ZQorCQkJCWFyY19rbWVtX3JlYXBfbm93KCk7CisjZW5kaWYKKwkJCQlEVFJBQ0VfUFJPQkUoYXJj X19yZWNsYWltX3Nocik7CiAJCQl9CiAJCX0gZWxzZSBpZiAoZnJlZV9tZW1vcnkgPCBhcmNfYyA+ PiBhcmNfbm9fZ3Jvd19zaGlmdCkgewogCQkJYXJjX25vX2dyb3cgPSBCX1RSVUU7CkBAIC02MzA4 LDIwICs2NDUxLDE0IEBAIHN0YXRpYyBldmVudGhhbmRsZXJfdGFnIGFyY19ldmVudF9sb3dtZW0g PSBOVUxMOwogc3RhdGljIHZvaWQKIGFyY19sb3dtZW0odm9pZCAqYXJnIF9fdW51c2VkLCBpbnQg aG93dG8gX191bnVzZWQpCiB7CisJaW50NjRfdCBuOwogCiAJbXV0ZXhfZW50ZXIoJmFyY19yZWNs YWltX2xvY2spOwogCS8qIFhYWDogTWVtb3J5IGRlZmljaXQgc2hvdWxkIGJlIHBhc3NlZCBhcyBh cmd1bWVudC4gKi8KLQluZWVkZnJlZSA9IGJ0b2MoYXJjX2MgPj4gYXJjX3Nocmlua19zaGlmdCk7 CisJbiA9IChpbnQ2NF90KXZtX2NudC52X2ZyZWVfdGFyZ2V0IC0gKGludDY0X3Qpdm1fY250LnZf ZnJlZV9jb3VudDsKKwluZWVkZnJlZSA9IChuPjApID8gbiA6IHZtX2NudC52X2ZyZWVfdGFyZ2V0 ID4+IDg7CiAJRFRSQUNFX1BST0JFKGFyY19fbmVlZGZyZWUpOwogCWN2X3NpZ25hbCgmYXJjX3Jl Y2xhaW1fdGhyZWFkX2N2KTsKLQotCS8qCi0JICogSXQgaXMgdW5zYWZlIHRvIGJsb2NrIGhlcmUg aW4gYXJiaXRyYXJ5IHRocmVhZHMsIGJlY2F1c2Ugd2UgY2FuIGNvbWUKLQkgKiBoZXJlIGZyb20g QVJDIGl0c2VsZiBhbmQgbWF5IGhvbGQgQVJDIGxvY2tzIGFuZCB0aHVzIHJpc2sgYSBkZWFkbG9j awotCSAqIHdpdGggQVJDIHJlY2xhaW0gdGhyZWFkLgotCSAqLwotCWlmIChjdXJwcm9jID09IHBh Z2Vwcm9jKQotCQkodm9pZCkgY3Zfd2FpdCgmYXJjX3JlY2xhaW1fd2FpdGVyc19jdiwgJmFyY19y ZWNsYWltX2xvY2spOwogCW11dGV4X2V4aXQoJmFyY19yZWNsYWltX2xvY2spOwogfQogI2VuZGlm CkBAIC02NjMyLDYgKzY3NjksOSBAQCBhcmNfaW5pdCh2b2lkKQogCQlwcmludGYoIiAgICAgICAg ICAgICBpbiAvYm9vdC9sb2FkZXIuY29uZi5cbiIpOwogCX0KICNlbmRpZgorI2lmZGVmCVdBS0Vf UEFHRVIKKwlhcmNfaW5pdF9kb25lKys7CisjZW5kaWYKIH0KIAogdm9pZApJbmRleDogdm0vdW1h LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gdm0vdW1hLmgJKHJldmlzaW9uIDMyNDA1NikKKysrIHZtL3VtYS5o CSh3b3JraW5nIGNvcHkpCkBAIC00NDgsNiArNDQ4LDE2IEBAIHZvaWQgdW1hX3N0YXJ0dXAyKHZv aWQpOwogdm9pZCB1bWFfcmVjbGFpbSh2b2lkKTsKIAogLyoKKyAqIFJlY2xhaW1zIHVudXNlZCBw ZXItQ1BVIGNhY2hlIG1lbW9yeSBmcm9tIHRoZSBzcGVjaWZpZWQgem9uZQorICoKKyAqIEFyZ3Vt ZW50czoKKyAqCXpvbmUgIFRoZSB6b25lIGZvciBjbGVhbnVwCisgKiBSZXR1cm5zOgorICoJTm9u ZQorICovCit2b2lkIHVtYV9yZWNsYWltX3pvbmVfY2FjaGUodW1hX3pvbmVfdCB6b25lKTsgCisK Ky8qCiAgKiBTZXRzIHRoZSBhbGlnbm1lbnQgbWFzayB0byBiZSB1c2VkIGZvciBhbGwgem9uZXMg cmVxdWVzdGluZyBjYWNoZQogICogYWxpZ25tZW50LiAgU2hvdWxkIGJlIGNhbGxlZCBieSBNRCBi b290IGNvZGUgcHJpb3IgdG8gc3RhcnRpbmcgVk0vVU1BLgogICoKQEAgLTU0NSw2ICs1NTUsMTgg QEAgdm9pZCB1bWFfem9uZV9zZXRfbWF4YWN0aW9uKHVtYV96b25lX3Qgem9uZSwgdW1hX20KIGlu dCB1bWFfem9uZV9nZXRfY3VyKHVtYV96b25lX3Qgem9uZSk7CiAKIC8qCisgKiBPYnRhaW5zIHRo ZSBhcHByb3hpbWF0ZSBjdXJyZW50IHNpemUgb2YgaXRlbXMgZnJlZSBpbiBhIHpvbmUKKyAqCisg KiBBcmd1bWVudHM6CisgKgl6b25lICBUaGUgem9uZSB0byBvYnRhaW4gdGhlIGN1cnJlbnQgZnJl ZSBzaXplIGZyb20KKyAqCisgKiBSZXR1cm46CisgKglpbnQgIFRoZSBhcHByb3hpbWF0ZSBjdXJy ZW50IHNpemUgb2YgaXRlbXMgZnJlZSBpbiBhIHpvbmUKKyAqLworc2l6ZV90IHVtYV96b25lX2dl dF9mcmVlX3NpemUodW1hX3pvbmVfdCB6b25lKTsKKworCisvKgogICogVGhlIGZvbGxvd2luZyB0 d28gcm91dGluZXMgKHVtYV96b25lX3NldF9pbml0L2ZpbmkpCiAgKiBhcmUgdXNlZCB0byBzZXQg dGhlIGJhY2tlbmQgaW5pdC9maW5pIHBhaXIgd2hpY2ggYWN0cyBvbiBhbgogICogb2JqZWN0IGFz IGl0IGJlY29tZXMgYWxsb2NhdGVkIGFuZCBpcyBwbGFjZWQgaW4gYSBzbGFiIHdpdGhpbgpJbmRl eDogdm0vdW1hX2NvcmUuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSB2bS91bWFfY29yZS5jCShyZXZpc2lvbiAz MjQwNTYpCisrKyB2bS91bWFfY29yZS5jCSh3b3JraW5nIGNvcHkpCkBAIC0yOTg3LDYgKzI5ODcs MzkgQEAgdW1hX3pvbmVfZ2V0X2N1cih1bWFfem9uZV90IHpvbmUpCiB9CiAKIC8qIFNlZSB1bWEu aCAqLworc2l6ZV90Cit1bWFfem9uZV9nZXRfZnJlZV9zaXplKHVtYV96b25lX3Qgem9uZSkKK3sK Kwl1bWFfa2xpbmtfdCBrbDsKKwl1bWFfYnVja2V0X3QgYnVja2V0OworCWludDY0X3Qgbml0ZW1z OworCXVfaW50IGk7CisKKwlaT05FX0xPQ0soem9uZSk7CisJbml0ZW1zID0gMDsKKwlpZighKHpv bmUtPnV6X2ZsYWdzICYgVU1BX1pPTkVfU0VDT05EQVJZKSkgeworCQlMSVNUX0ZPUkVBQ0goa2ws ICZ6b25lLT51el9rZWdzLCBrbF9saW5rKSB7CisJCQluaXRlbXMgKz0ga2wtPmtsX2tlZy0+dWtf ZnJlZTsKKwkJfQorCX0KKwlDUFVfRk9SRUFDSChpKSB7CisJCS8qCisJCSAqIFNlZSB0aGUgY29t bWVudCBpbiBzeXNjdGxfdm1fem9uZV9zdGF0cygpIHJlZ2FyZGluZyB0aGUKKwkJICogc2FmZXR5 IG9mIGFjY2Vzc2luZyB0aGUgcGVyLWNwdSBjYWNoZXMuIFdpdGggdGhlIHpvbmUgbG9jaworCQkg KiBoZWxkLCBpdCBpcyBzYWZlLCBidXQgY2FuIHBvdGVudGlhbGx5IHJlc3VsdCBpbiBzdGFsZSBk YXRhLgorCQkgKi8KKwkJYnVja2V0ID0gem9uZS0+dXpfY3B1W2ldLnVjX2FsbG9jYnVja2V0Owor CQlpZiAoYnVja2V0ICE9IE5VTEwpCisJCQluaXRlbXMgKz0gYnVja2V0LT51Yl9jbnQ7CisJCWJ1 Y2tldCA9IHpvbmUtPnV6X2NwdVtpXS51Y19mcmVlYnVja2V0OworCQlpZiAoYnVja2V0ICE9IE5V TEwpCisJCQluaXRlbXMgKz0gYnVja2V0LT51Yl9jbnQ7CisJfQorCVpPTkVfVU5MT0NLKHpvbmUp OworCXJldHVybiAobml0ZW1zICogem9uZS0+dXpfc2l6ZSk7Cit9CisKKy8qIFNlZSB1bWEuaCAq Lwogdm9pZAogdW1hX3pvbmVfc2V0X2luaXQodW1hX3pvbmVfdCB6b25lLCB1bWFfaW5pdCB1bWlu aXQpCiB7CkBAIC0zMTUyLDYgKzMxODUsMTQgQEAgdW1hX3ByZWFsbG9jKHVtYV96b25lX3Qgem9u ZSwgaW50IGl0ZW1zKQogfQogCiAvKiBTZWUgdW1hLmggKi8KK3ZvaWQKK3VtYV9yZWNsYWltX3pv bmVfY2FjaGUodW1hX3pvbmVfdCB6b25lKQoreworCWJ1Y2tldF9lbmFibGUoKTsKKwljYWNoZV9k cmFpbl9zYWZlKHpvbmUpOworfQorCisvKiBTZWUgdW1hLmggKi8KIHN0YXRpYyB2b2lkCiB1bWFf cmVjbGFpbV9sb2NrZWQoYm9vbCBrbWVtX2RhbmdlcikKIHsK