From: Dan Magenheimer Subject: [PATCH] tsc_mode documentation Date: Tue, 1 Dec 2009 10:26:46 -0800 (PST) Message-ID: <7ae2c42c-c057-4667-9a42-cdf89b8f40de@default> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="__125969202969068996abhmt003.oracle.com" Return-path: List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xensource.com Errors-To: xen-devel-bounces@lists.xensource.com To: "Xen-Devel (E-mail)" List-Id: xen-devel@lists.xenproject.org --__125969202969068996abhmt003.oracle.com Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Detailed documentation(!) for the new tsc_mode VM configuration option (Note, new file to be hg add'ed.) Signed-off-by: Dan Magenheimer diff -r d0b030008814 docs/misc/tscmode.txt --- /dev/null=09Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/misc/tscmode.txt=09Tue Dec 01 11:23:19 2009 -0700 @@ -0,0 +1,299 @@ +TSC_MODE HOW-TO +by: Dan Magenheimer + +OVERVIEW + +As of Xen 4.0, a new config option called tsc_mode may be specified +for each domain. The default for tsc_mode handles the vast majority +of hardware and software environments. This document is targeted +for Xen users and administrators that may need to select a non-default +tsc_mode. + +Proper selection of tsc_mode depends on an understanding not only of +the guest operating system (OS), but also of the application set that will +ever run on this guest OS. This is because tsc_mode applies +equally to both the OS and ALL apps that are running on this +domain, now or in the future. + +Key questions to be answered for the OS and/or each application are: +- Does the OS/app use the rdtsc instruction at all? (We will explain belo= w + how to determine this.) +- At what frequency is the rdtsc instruction executed by either the OS + or any running apps? If the sum exceeds about 10,000 rdtsc instructions + per second per processor, we call this a "high-TSC-frequency" + OS/app/environment. (This is relatively rare, and developers of OS's + and apps that are high-TSC-frequency are usually aware of it.) +- If the OS/app does use rdtsc, will it behave incorrectly if "time goes + backwards" or if the frequency of the TSC suddenly changes? If so, + we call this a "TSC-sensitive" app or OS; otherwise it is "TSC-resilient= ". + +This last is the US$64,000 question as it may be very difficult +(or, for legacy apps, even impossible) to predict all possible +failure cases. As a result, unless proven otherwise, any app +that uses rdtsc must be assumed to be TSC-sensitive and, as we +will see, this is the default starting in Xen 4.0. + +Xen's new tsc_mode parameter determines the circumstances under which +the family of rdtsc instructions are executed "natively" vs emulated. +Roughly speaking, native means rdtsc is fast but TSC-sensitive apps +may, under unpredictable circumstances, run incorrectly; emulated means +there is some performance degradation (unobservable in most cases), +but TSC-sensitive apps will always run correctly. Prior to Xen 4.0, +all rdtsc instructions were native: "fast but potentially incorrect." +Starting at Xen 4.0, the default is that all rdtsc instructions are +"correct but potentially slow". The tsc_mode parameter in 4.0 provides +an intelligent default but allows system administrator's to adjust +how rdtsc instructions are executed differently for different domains. + +The non-default choices for tsc_mode are: +- tsc_mode=3D1 (always emulate). All rdtsc instructions are emulated; + this is the best choice when TSC-sensitive apps are running and + it is necessary to understand worst-case performance degradation + for a specific hardware environment. +- tsc_mode=3D2 (never emulate). This is the same as prior to Xen 4.0 + and is the best choice if it is certain that all apps running in + this VM are TSC-resilient and highest performance is required. +- tsc_mode=3D3 (PVRDTSCP). High-TSC-frequency apps may be paravirtualized + (modified) to obtain both correctness and highest performance; any + unmodified apps must be TSC-resilient. + +If tsc_mode is left unspecified (or set to tsc_mode=3D0), a hybrid +algorithm is utilized to ensure correctness while providing the +best performance possible given: +- the requirement of correctness, +- the underlying hardware, and +- whether or not the VM has been saved/restored/migrated +To understand this in more detail, the rest of this document must +be read. + +DETERMINING RDTSC FREQUENCY + +To determine the frequency of rdtsc instructions that are emulated, +an "xm" command can be used by a privileged user of domain0. The +command: + +# xm debug-key s; xm dmesg | tail + +provides information about TSC usage in each domain where TSC +emulation is currently enabled. + +TSC HISTORY + +To understand tsc_mode completely, some background on TSC is required: + +The x86 "timestamp counter", or TSC, is a 64-bit register on each +processor that increases monotonically. Historically, TSC incremented +every processor cycle, but on recent processors, it increases +at a constant rate even if the processor changes frequency (for example, +to reduce processor power usage). TSC is known by x86 programmers +as the fastest, highest-precision measurement of the passage of time +so it is often used as a foundation for performance monitoring. +And since it is guaranteed to be monotonically increasing and, at +64 bits, is guaranteed to not wraparound within 10 years, it is +sometimes used as a random number or a unique sequence identifier, +such as to stamp transactions so they can be replayed in a specific +order. + +On most older SMP and early multi-core machines, TSC was not synchronized +between processors. Thus if an application were to read the TSC on +one processor, then was moved by the OS to another processor, then read +TSC again, it might appear that "time went backwards". This loss of +monotonicity resulted in many obscure application bugs when TSC-sensitive +apps were ported from a uniprocessor to an SMP environment; as a result, +many applications -- especially in the Windows world -- removed their +dependency on TSC and replaced their timestamp needs with OS-specific +functions, losing both performance and precision. On some more recent +generations of multi-core machines, especially multi-socket multi-core +machines, the TSC was synchronized but if one processor were to enter +certain low-power states, its TSC would stop, destroying the synchrony +and again causing obscure bugs. This reinforced decisions to avoid use +of TSC altogether. On the most recent generations of multi-core +machines, however, synchronization is provided across all processors +in all power states, even on multi-socket machines, and provide a +flag that indicates that TSC is synchronized and "invariant". Thus +TSC is once again useful for applications, and even newer operating +systems are using and depending upon TSC for critical timekeeping +tasks when running on these recent machines. + +We will refer to hardware that ensures TSC is both synchronized and +invariant as "TSC-safe" and any hardware on which TSC is not (or +may not remain) synchronized as "TSC-unsafe". + +As a result of TSC's sordid history, two classes of applications use +TSC: old applications designed for single processors, and the most recent +enteprise applications which require high-frequency high-precision +timestamping. + +We will refer to apps that might break if running on a TSC-unsafe +machine as "TSC-sensitive"; apps that don't use TSC, or do use +TSC but use it in a way that monotonicity and frequency invariance +are unimportant as "TSC-resilient". + +The emergence of virtualization once again complicates the usage of +TSC. When features such as save/restore or live migration are employed, +a guest OS and all its currently running applications may be invisibly +transported to an entirely different physical machine. While TSC +may be "safe" on one machine, it is essentially impossible to precisely +synchronize TSC across a data center or even a pool of machines. As +a result, when run in a virtualized environment, rare and obscure +"time going backwards" problems might once again occur for those +TSC-sensitive applications. Worse, if a guest OS moves from, for +example, a 3GHz +machine to a 1.5GHz machine, attempts by an OS/app to measure time +intervals with TSC may without notice be incorrect by a factor of two. + +The rdtsc (read timestamp counter) instruction is used to read the +TSC register. The rdtscp instruction is a variant of rdtsc on recent +processors. We refer to these together as the rdtsc family of instruction= s, +or just "rdtsc". Instructions in the rdtsc family are non-privileged, but +privileged software may set a cpuid bit to cause all rdtsc family +instructions to trap. This trap can be detected by Xen, which can +then transparently "emulate" the results of the rdtsc instruction and +return control to the code following the rdtsc instruction. + +To provide a "safe" TSC, i.e. to ensure both TSC monontonicity and a +fixed rate, Xen provides rdtsc emulation whenever necessary or when +explicitly specified by a per-VM configuration option. TSC emulation is +relatively slow -- roughly 15-20 times slower than the rdtsc instruction +when executed natively. However, except when an OS or application uses +the rdtsc instruction at a high frequency (e.g. more than about 10,000 tim= es +per second per processor), this performance degradation is not noticable +(i.e. <0.3%). And, TSC emulation is nearly always faster than +OS-provided alternatives (e.g. Linux's gettimeofday). For environments +where it is certain that all apps are TSC-resilient (e.g. +"TSC-safeness" is not necessary) and highest performance is a +requirement, TSC emulation may be entirely disabled (tsc_mode=3D=3D2). + +The default mode (tsc_mode=3D=3D0) checks TSC-safeness of the underlying +hardware on which the virtual machine is launched. If it is +TSC-safe, rdtsc will execute at hardware speed; if it is not, rdtsc +will be emulated. Once a virtual machine is save/restored or migrated, +however, there are two possibilities: For a paravirtualized (PV) domain, +TSC will always be emulated. For a fully-virtualized (HVM) domain, +TSC remains native IF the source physical machine and target physical mach= ine +have the same TSC frequency; else TSC is emulated. Note that, though +emulated, the "apparent" TSC frequency will be the TSC frequency +of the initial physical machine, even after migration. + +For environments where both TSC-safeness AND highest performance +even across migration is a requirement, application code can be specially +modified to use an algorithm explicitly designed into Xen for this purpose= . +This mode (tsc_mode=3D=3D3) is called PVRDTSCP, because it requires +app paravirtualization (awareness by the app that it may be running +on top of Xen), and utilizes a variation of the rdtsc instruction +called rdtscp that is available on most recent generation processors. +(The rdtscp instruction differs from the rdtsc instruction in that it +reads not only the TSC but an additional register set by system software.) +When a pvrdtscp-modified app is running on a processor that is both TSC-sa= fe +and supports the rdtscp instruction, information can be obtained +about migration and TSC frequency/offset adjustment to allow the +vast majority of timestamps to be obtained at top performance; when +running on a TSC-unsafe processor or a processor that doesn't support +the rdtscp instruction, rdtscp is emulated. + +PVRDTSCP (tsc_mode=3D=3D3) has two limitations. First, it applies to +all apps running in this virtual machine. This means that all +apps must either be TSC-resilient or pvrdtscp-modified. Second, +highest performance is only obtained on TSC-safe machines that +support the rdtscp instruction; when running on older machines, +rdtscp is emulated and thus slower. For more information on PVRTSCP, +see below. + +Finally, tsc_mode=3D=3D1 always enables TSC emulation, regardless of +the underlying physical hardware. The "apparent" TSC frequency will +be the TSC frequency of the initial physical machine, even after migration= . +This mode is useful to measure any performance degradation that +might be encountered by a tsc_mode=3D=3D0 domain after migration occurs, +or a tsc_mode=3D=3D3 domain when it is running on TSC-unsafe hardware. + +Note that while Xen ensures that an emulated TSC is "safe" across migratio= n, +it does not ensure that it continues to tick at the same rate during +the actual migration. As an oversimplified example, if TSC is ticking +once per second in a guest, and the guest is saved when the TSC is 1000, +then restored 30 seconds later, TSC is only guaranteed to be greater +than or equal to 1001, not precisely 1030. This has some OS implications +as will be seen in the next section. + +TSC INVARIANT BIT and NO_MIGRATE + +Related to TSC emulation, the "TSC Invariant" bit is architecturally defin= ed +in a cpuid bit on the most recent x86 processors. If set, TSC invariance +ensures that the TSC is "safe", that is it will increment at a constant ra= te +regardless of power events, will be synchronized across all processors, an= d +was properly initialized to zero on all processors at boot-time +by system hardware/BIOS. As long as system software never writes to TSC, +TSC will be safe and continuously incremented at a fixed rate and thus +can be used as a system "clocksource". + +This bit is used by some OS's, and specifically by Linux starting with +version 2.6.30(?), to select TSC as a system clocksource. Once selected, +TSC remains the Linux system clocksource unless manually overridden. In +a virtualized environment, since it is not possible to synchronize TSC +across all the machines in a pool or data center, a migration may "break" +TSC as a usable clocksource; while time will not go backwards, it may +not track wallclock time well enough to avoid certain time-sensitive +consequences. As a result, Xen can only expose the TSC Invariant bit +to a guest OS if it is certain that the domain will never migrate. +As of Xen 4.0, the "no_migrate=3D1" VM configuration option may be specifi= ed +to disable migration. If no_migrate is selected and the VM is running +on a physical machine with "TSC Invariant", Linux 2.6.30+ will safely +use TSC as the system clocksource. But, attempts to migrate or, once +saved, restore this domain will fail. + +There is another cpuid-related complication: The x86 cpuid instruction is +non-privileged. HVM domains are configured to always trap this instructio= n +to Xen, where Xen can "filter" the result. In a PV OS, all cpuid instruct= ions +have been replaced by a parvirtualized equivalent of the cpuid instruction +("pvcpuid") and also trap to Xen. But apps in a PV guest that use a +cpuid instruction execute it directly, without a trap to Xen. As a result= , +an app may directly examine the physical TSC Invariant cpuid bit and make +decisions based on that bit. This is still an unsolved problem, though +a workaround exists as part of the PVRDTSCP tsc_mode for apps that +can be modified. + +MORE ON PVRDTSCP + +Paravirtualized OS's use the "pvclock" algorithm to manage the passing +of time. This sophisticated algorithm obtains information from a memory +page shared between Xen and the OS and selects information from this +page based on the current virtual CPU (vcpu) in order to properly adapt to +TSC-unsafe systems and changes that occur across migration. Neither +this shared page nor the vcpu information is available to a userland +app so the pvclock algorithm cannot be directly used by an app, at least +without performance degradation roughly equal to the cost of just +emulating an rdtsc. + +As a result, as of 4.0, Xen provides capabilities for a userland app +to obtain key time values similar to the information accessible +to the PV OS pvclock algorithm. The app uses the rdtscp instruction +which is defined in recent processors to obtain both the TSC and an +auxiliary value called TSC_AUX. Xen is responsible for setting TSC_AUX +to the same value on all vcpus running any domain with tsc_mode=3D=3D3; +further, Xen tools are responsible for monotonically incrementing TSC_AUX +anytime the domain is restored/migrated (thus changing key time values); +and, when the domain is running on a physical machine that either +is not TSC-safe or does not support the rdtscp instruction, Xen +is responsible for emulating the rdtscp instruction and for setting +TSC_AUX to zero on all processors. + +Xen also provides pvclock information via a "pvcpuid" instruction. +While this results in a slow trap, the information changes +(and thus must be reobtained via pvcpuid) ONLY when TSC_AUX +has changed, which should be very rare relative to a high +frequency of rdtscp instructions. + +Finally, Xen provides additional time-related information via +other pvcpuid instructions. First, an app is capable of +determining if it is currently running on Xen, next whether +the tsc_mode setting of the domain in which it is running, +and finally whether the underlying hardware is TSC-safe and +supports the rdtscp instruction. + +As a result, a pvrdtscp-modified app has sufficient information +to compute the pvclock "elapsed nanoseconds" which can +be used as a timestamp. And this can be done nearly as +fast as a native rdtsc instruction, much faster than emulation, +and also much faster than nearly all OS-provided time mechanisms. +While pvrtscp is too complex for most apps, certain enterprise +TSC-sensitive high-TSC-frequency apps may find it useful to +obtain a significant performance gain. --__125969202969068996abhmt003.oracle.com Content-Type: application/octet-stream; name="tscmode-doc.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="tscmode-doc.patch" ZGlmZiAtciBkMGIwMzAwMDg4MTQgZG9jcy9taXNjL3RzY21vZGUudHh0Ci0tLSAvZGV2L251bGwJ VGh1IEphbiAwMSAwMDowMDowMCAxOTcwICswMDAwCisrKyBiL2RvY3MvbWlzYy90c2Ntb2RlLnR4 dAlUdWUgRGVjIDAxIDExOjIzOjE5IDIwMDkgLTA3MDAKQEAgLTAsMCArMSwyOTkgQEAKK1RTQ19N T0RFIEhPVy1UTworYnk6IERhbiBNYWdlbmhlaW1lciA8ZGFuLm1hZ2VuaGVpbWVyQG9yYWNsZS5j b20+CisKK09WRVJWSUVXCisKK0FzIG9mIFhlbiA0LjAsIGEgbmV3IGNvbmZpZyBvcHRpb24gY2Fs bGVkIHRzY19tb2RlIG1heSBiZSBzcGVjaWZpZWQKK2ZvciBlYWNoIGRvbWFpbi4gIFRoZSBkZWZh dWx0IGZvciB0c2NfbW9kZSBoYW5kbGVzIHRoZSB2YXN0IG1ham9yaXR5CitvZiBoYXJkd2FyZSBh bmQgc29mdHdhcmUgZW52aXJvbm1lbnRzLiAgVGhpcyBkb2N1bWVudCBpcyB0YXJnZXRlZAorZm9y IFhlbiB1c2VycyBhbmQgYWRtaW5pc3RyYXRvcnMgdGhhdCBtYXkgbmVlZCB0byBzZWxlY3QgYSBu b24tZGVmYXVsdAordHNjX21vZGUuCisKK1Byb3BlciBzZWxlY3Rpb24gb2YgdHNjX21vZGUgZGVw ZW5kcyBvbiBhbiB1bmRlcnN0YW5kaW5nIG5vdCBvbmx5IG9mCit0aGUgZ3Vlc3Qgb3BlcmF0aW5n IHN5c3RlbSAoT1MpLCBidXQgYWxzbyBvZiB0aGUgYXBwbGljYXRpb24gc2V0IHRoYXQgd2lsbAor ZXZlciBydW4gb24gdGhpcyBndWVzdCBPUy4gIFRoaXMgaXMgYmVjYXVzZSB0c2NfbW9kZSBhcHBs aWVzCitlcXVhbGx5IHRvIGJvdGggdGhlIE9TIGFuZCBBTEwgYXBwcyB0aGF0IGFyZSBydW5uaW5n IG9uIHRoaXMKK2RvbWFpbiwgbm93IG9yIGluIHRoZSBmdXR1cmUuCisKK0tleSBxdWVzdGlvbnMg dG8gYmUgYW5zd2VyZWQgZm9yIHRoZSBPUyBhbmQvb3IgZWFjaCBhcHBsaWNhdGlvbiBhcmU6Cist IERvZXMgdGhlIE9TL2FwcCB1c2UgdGhlIHJkdHNjIGluc3RydWN0aW9uIGF0IGFsbD8gIChXZSB3 aWxsIGV4cGxhaW4gYmVsb3cKKyAgaG93IHRvIGRldGVybWluZSB0aGlzLikKKy0gQXQgd2hhdCBm cmVxdWVuY3kgaXMgdGhlIHJkdHNjIGluc3RydWN0aW9uIGV4ZWN1dGVkIGJ5IGVpdGhlciB0aGUg T1MKKyAgb3IgYW55IHJ1bm5pbmcgYXBwcz8gIElmIHRoZSBzdW0gZXhjZWVkcyBhYm91dCAxMCww MDAgcmR0c2MgaW5zdHJ1Y3Rpb25zCisgIHBlciBzZWNvbmQgcGVyIHByb2Nlc3Nvciwgd2UgY2Fs bCB0aGlzIGEgImhpZ2gtVFNDLWZyZXF1ZW5jeSIKKyAgT1MvYXBwL2Vudmlyb25tZW50LiAgKFRo aXMgaXMgcmVsYXRpdmVseSByYXJlLCBhbmQgZGV2ZWxvcGVycyBvZiBPUydzCisgIGFuZCBhcHBz IHRoYXQgYXJlIGhpZ2gtVFNDLWZyZXF1ZW5jeSBhcmUgdXN1YWxseSBhd2FyZSBvZiBpdC4pCist IElmIHRoZSBPUy9hcHAgZG9lcyB1c2UgcmR0c2MsIHdpbGwgaXQgYmVoYXZlIGluY29ycmVjdGx5 IGlmICJ0aW1lIGdvZXMKKyAgYmFja3dhcmRzIiBvciBpZiB0aGUgZnJlcXVlbmN5IG9mIHRoZSBU U0Mgc3VkZGVubHkgY2hhbmdlcz8gIElmIHNvLAorICB3ZSBjYWxsIHRoaXMgYSAiVFNDLXNlbnNp dGl2ZSIgYXBwIG9yIE9TOyBvdGhlcndpc2UgaXQgaXMgIlRTQy1yZXNpbGllbnQiLgorCitUaGlz IGxhc3QgaXMgdGhlIFVTJDY0LDAwMCBxdWVzdGlvbiBhcyBpdCBtYXkgYmUgdmVyeSBkaWZmaWN1 bHQKKyhvciwgZm9yIGxlZ2FjeSBhcHBzLCBldmVuIGltcG9zc2libGUpIHRvIHByZWRpY3QgYWxs IHBvc3NpYmxlCitmYWlsdXJlIGNhc2VzLiAgQXMgYSByZXN1bHQsIHVubGVzcyBwcm92ZW4gb3Ro ZXJ3aXNlLCBhbnkgYXBwCit0aGF0IHVzZXMgcmR0c2MgbXVzdCBiZSBhc3N1bWVkIHRvIGJlIFRT Qy1zZW5zaXRpdmUgYW5kLCBhcyB3ZQord2lsbCBzZWUsIHRoaXMgaXMgdGhlIGRlZmF1bHQgc3Rh cnRpbmcgaW4gWGVuIDQuMC4KKworWGVuJ3MgbmV3IHRzY19tb2RlIHBhcmFtZXRlciBkZXRlcm1p bmVzIHRoZSBjaXJjdW1zdGFuY2VzIHVuZGVyIHdoaWNoCit0aGUgZmFtaWx5IG9mIHJkdHNjIGlu c3RydWN0aW9ucyBhcmUgZXhlY3V0ZWQgIm5hdGl2ZWx5IiB2cyBlbXVsYXRlZC4KK1JvdWdobHkg c3BlYWtpbmcsIG5hdGl2ZSBtZWFucyByZHRzYyBpcyBmYXN0IGJ1dCBUU0Mtc2Vuc2l0aXZlIGFw cHMKK21heSwgdW5kZXIgdW5wcmVkaWN0YWJsZSBjaXJjdW1zdGFuY2VzLCBydW4gaW5jb3JyZWN0 bHk7IGVtdWxhdGVkIG1lYW5zCit0aGVyZSBpcyBzb21lIHBlcmZvcm1hbmNlIGRlZ3JhZGF0aW9u ICh1bm9ic2VydmFibGUgaW4gbW9zdCBjYXNlcyksCitidXQgVFNDLXNlbnNpdGl2ZSBhcHBzIHdp bGwgYWx3YXlzIHJ1biBjb3JyZWN0bHkuICBQcmlvciB0byBYZW4gNC4wLAorYWxsIHJkdHNjIGlu c3RydWN0aW9ucyB3ZXJlIG5hdGl2ZTogImZhc3QgYnV0IHBvdGVudGlhbGx5IGluY29ycmVjdC4i CitTdGFydGluZyBhdCBYZW4gNC4wLCB0aGUgZGVmYXVsdCBpcyB0aGF0IGFsbCByZHRzYyBpbnN0 cnVjdGlvbnMgYXJlCisiY29ycmVjdCBidXQgcG90ZW50aWFsbHkgc2xvdyIuICBUaGUgdHNjX21v ZGUgcGFyYW1ldGVyIGluIDQuMCBwcm92aWRlcworYW4gaW50ZWxsaWdlbnQgZGVmYXVsdCBidXQg YWxsb3dzIHN5c3RlbSBhZG1pbmlzdHJhdG9yJ3MgdG8gYWRqdXN0Citob3cgcmR0c2MgaW5zdHJ1 Y3Rpb25zIGFyZSBleGVjdXRlZCBkaWZmZXJlbnRseSBmb3IgZGlmZmVyZW50IGRvbWFpbnMuCisK K1RoZSBub24tZGVmYXVsdCBjaG9pY2VzIGZvciB0c2NfbW9kZSBhcmU6CistIHRzY19tb2RlPTEg KGFsd2F5cyBlbXVsYXRlKS4gQWxsIHJkdHNjIGluc3RydWN0aW9ucyBhcmUgZW11bGF0ZWQ7Cisg ICB0aGlzIGlzIHRoZSBiZXN0IGNob2ljZSB3aGVuIFRTQy1zZW5zaXRpdmUgYXBwcyBhcmUgcnVu bmluZyBhbmQKKyAgIGl0IGlzIG5lY2Vzc2FyeSB0byB1bmRlcnN0YW5kIHdvcnN0LWNhc2UgcGVy Zm9ybWFuY2UgZGVncmFkYXRpb24KKyAgIGZvciBhIHNwZWNpZmljIGhhcmR3YXJlIGVudmlyb25t ZW50LgorLSB0c2NfbW9kZT0yIChuZXZlciBlbXVsYXRlKS4gIFRoaXMgaXMgdGhlIHNhbWUgYXMg cHJpb3IgdG8gWGVuIDQuMAorICAgYW5kIGlzIHRoZSBiZXN0IGNob2ljZSBpZiBpdCBpcyBjZXJ0 YWluIHRoYXQgYWxsIGFwcHMgcnVubmluZyBpbgorICAgdGhpcyBWTSBhcmUgVFNDLXJlc2lsaWVu dCBhbmQgaGlnaGVzdCBwZXJmb3JtYW5jZSBpcyByZXF1aXJlZC4KKy0gdHNjX21vZGU9MyAoUFZS RFRTQ1ApLiAgSGlnaC1UU0MtZnJlcXVlbmN5IGFwcHMgbWF5IGJlIHBhcmF2aXJ0dWFsaXplZAor ICAgKG1vZGlmaWVkKSB0byBvYnRhaW4gYm90aCBjb3JyZWN0bmVzcyBhbmQgaGlnaGVzdCBwZXJm b3JtYW5jZTsgYW55CisgICB1bm1vZGlmaWVkIGFwcHMgbXVzdCBiZSBUU0MtcmVzaWxpZW50Lgor CitJZiB0c2NfbW9kZSBpcyBsZWZ0IHVuc3BlY2lmaWVkIChvciBzZXQgdG8gdHNjX21vZGU9MCks IGEgaHlicmlkCithbGdvcml0aG0gaXMgdXRpbGl6ZWQgdG8gZW5zdXJlIGNvcnJlY3RuZXNzIHdo aWxlIHByb3ZpZGluZyB0aGUKK2Jlc3QgcGVyZm9ybWFuY2UgcG9zc2libGUgZ2l2ZW46CistIHRo ZSByZXF1aXJlbWVudCBvZiBjb3JyZWN0bmVzcywKKy0gdGhlIHVuZGVybHlpbmcgaGFyZHdhcmUs IGFuZAorLSB3aGV0aGVyIG9yIG5vdCB0aGUgVk0gaGFzIGJlZW4gc2F2ZWQvcmVzdG9yZWQvbWln cmF0ZWQKK1RvIHVuZGVyc3RhbmQgdGhpcyBpbiBtb3JlIGRldGFpbCwgdGhlIHJlc3Qgb2YgdGhp cyBkb2N1bWVudCBtdXN0CitiZSByZWFkLgorCitERVRFUk1JTklORyBSRFRTQyBGUkVRVUVOQ1kK KworVG8gZGV0ZXJtaW5lIHRoZSBmcmVxdWVuY3kgb2YgcmR0c2MgaW5zdHJ1Y3Rpb25zIHRoYXQg YXJlIGVtdWxhdGVkLAorYW4gInhtIiBjb21tYW5kIGNhbiBiZSB1c2VkIGJ5IGEgcHJpdmlsZWdl ZCB1c2VyIG9mIGRvbWFpbjAuICBUaGUKK2NvbW1hbmQ6CisKKyMgeG0gZGVidWcta2V5IHM7IHht IGRtZXNnIHwgdGFpbAorCitwcm92aWRlcyBpbmZvcm1hdGlvbiBhYm91dCBUU0MgdXNhZ2UgaW4g ZWFjaCBkb21haW4gd2hlcmUgVFNDCitlbXVsYXRpb24gaXMgY3VycmVudGx5IGVuYWJsZWQuCisK K1RTQyBISVNUT1JZCisKK1RvIHVuZGVyc3RhbmQgdHNjX21vZGUgY29tcGxldGVseSwgc29tZSBi YWNrZ3JvdW5kIG9uIFRTQyBpcyByZXF1aXJlZDoKKworVGhlIHg4NiAidGltZXN0YW1wIGNvdW50 ZXIiLCBvciBUU0MsIGlzIGEgNjQtYml0IHJlZ2lzdGVyIG9uIGVhY2gKK3Byb2Nlc3NvciB0aGF0 IGluY3JlYXNlcyBtb25vdG9uaWNhbGx5LiAgSGlzdG9yaWNhbGx5LCBUU0MgaW5jcmVtZW50ZWQK K2V2ZXJ5IHByb2Nlc3NvciBjeWNsZSwgYnV0IG9uIHJlY2VudCBwcm9jZXNzb3JzLCBpdCBpbmNy ZWFzZXMKK2F0IGEgY29uc3RhbnQgcmF0ZSBldmVuIGlmIHRoZSBwcm9jZXNzb3IgY2hhbmdlcyBm cmVxdWVuY3kgKGZvciBleGFtcGxlLAordG8gcmVkdWNlIHByb2Nlc3NvciBwb3dlciB1c2FnZSku ICBUU0MgaXMga25vd24gYnkgeDg2IHByb2dyYW1tZXJzCithcyB0aGUgZmFzdGVzdCwgaGlnaGVz dC1wcmVjaXNpb24gbWVhc3VyZW1lbnQgb2YgdGhlIHBhc3NhZ2Ugb2YgdGltZQorc28gaXQgaXMg b2Z0ZW4gdXNlZCBhcyBhIGZvdW5kYXRpb24gZm9yIHBlcmZvcm1hbmNlIG1vbml0b3JpbmcuCitB bmQgc2luY2UgaXQgaXMgZ3VhcmFudGVlZCB0byBiZSBtb25vdG9uaWNhbGx5IGluY3JlYXNpbmcg YW5kLCBhdAorNjQgYml0cywgaXMgZ3VhcmFudGVlZCB0byBub3Qgd3JhcGFyb3VuZCB3aXRoaW4g MTAgeWVhcnMsIGl0IGlzCitzb21ldGltZXMgdXNlZCBhcyBhIHJhbmRvbSBudW1iZXIgb3IgYSB1 bmlxdWUgc2VxdWVuY2UgaWRlbnRpZmllciwKK3N1Y2ggYXMgdG8gc3RhbXAgdHJhbnNhY3Rpb25z IHNvIHRoZXkgY2FuIGJlIHJlcGxheWVkIGluIGEgc3BlY2lmaWMKK29yZGVyLgorCitPbiBtb3N0 IG9sZGVyIFNNUCBhbmQgZWFybHkgbXVsdGktY29yZSBtYWNoaW5lcywgVFNDIHdhcyBub3Qgc3lu Y2hyb25pemVkCitiZXR3ZWVuIHByb2Nlc3NvcnMuICBUaHVzIGlmIGFuIGFwcGxpY2F0aW9uIHdl cmUgdG8gcmVhZCB0aGUgVFNDIG9uCitvbmUgcHJvY2Vzc29yLCB0aGVuIHdhcyBtb3ZlZCBieSB0 aGUgT1MgdG8gYW5vdGhlciBwcm9jZXNzb3IsIHRoZW4gcmVhZAorVFNDIGFnYWluLCBpdCBtaWdo dCBhcHBlYXIgdGhhdCAidGltZSB3ZW50IGJhY2t3YXJkcyIuICBUaGlzIGxvc3Mgb2YKK21vbm90 b25pY2l0eSByZXN1bHRlZCBpbiBtYW55IG9ic2N1cmUgYXBwbGljYXRpb24gYnVncyB3aGVuIFRT Qy1zZW5zaXRpdmUKK2FwcHMgd2VyZSBwb3J0ZWQgZnJvbSBhIHVuaXByb2Nlc3NvciB0byBhbiBT TVAgZW52aXJvbm1lbnQ7IGFzIGEgcmVzdWx0LAorbWFueSBhcHBsaWNhdGlvbnMgLS0gZXNwZWNp YWxseSBpbiB0aGUgV2luZG93cyB3b3JsZCAtLSByZW1vdmVkIHRoZWlyCitkZXBlbmRlbmN5IG9u IFRTQyBhbmQgcmVwbGFjZWQgdGhlaXIgdGltZXN0YW1wIG5lZWRzIHdpdGggT1Mtc3BlY2lmaWMK K2Z1bmN0aW9ucywgbG9zaW5nIGJvdGggcGVyZm9ybWFuY2UgYW5kIHByZWNpc2lvbi4gT24gc29t ZSBtb3JlIHJlY2VudAorZ2VuZXJhdGlvbnMgb2YgbXVsdGktY29yZSBtYWNoaW5lcywgZXNwZWNp YWxseSBtdWx0aS1zb2NrZXQgbXVsdGktY29yZQorbWFjaGluZXMsIHRoZSBUU0Mgd2FzIHN5bmNo cm9uaXplZCBidXQgaWYgb25lIHByb2Nlc3NvciB3ZXJlIHRvIGVudGVyCitjZXJ0YWluIGxvdy1w b3dlciBzdGF0ZXMsIGl0cyBUU0Mgd291bGQgc3RvcCwgZGVzdHJveWluZyB0aGUgc3luY2hyb255 CithbmQgYWdhaW4gY2F1c2luZyBvYnNjdXJlIGJ1Z3MuICBUaGlzIHJlaW5mb3JjZWQgZGVjaXNp b25zIHRvIGF2b2lkIHVzZQorb2YgVFNDIGFsdG9nZXRoZXIuICBPbiB0aGUgbW9zdCByZWNlbnQg Z2VuZXJhdGlvbnMgb2YgbXVsdGktY29yZQorbWFjaGluZXMsIGhvd2V2ZXIsIHN5bmNocm9uaXph dGlvbiBpcyBwcm92aWRlZCBhY3Jvc3MgYWxsIHByb2Nlc3NvcnMKK2luIGFsbCBwb3dlciBzdGF0 ZXMsIGV2ZW4gb24gbXVsdGktc29ja2V0IG1hY2hpbmVzLCBhbmQgcHJvdmlkZSBhCitmbGFnIHRo YXQgaW5kaWNhdGVzIHRoYXQgVFNDIGlzIHN5bmNocm9uaXplZCBhbmQgImludmFyaWFudCIuICBU aHVzCitUU0MgaXMgb25jZSBhZ2FpbiB1c2VmdWwgZm9yIGFwcGxpY2F0aW9ucywgYW5kIGV2ZW4g bmV3ZXIgb3BlcmF0aW5nCitzeXN0ZW1zIGFyZSB1c2luZyBhbmQgZGVwZW5kaW5nIHVwb24gVFND IGZvciBjcml0aWNhbCB0aW1la2VlcGluZwordGFza3Mgd2hlbiBydW5uaW5nIG9uIHRoZXNlIHJl Y2VudCBtYWNoaW5lcy4KKworV2Ugd2lsbCByZWZlciB0byBoYXJkd2FyZSB0aGF0IGVuc3VyZXMg VFNDIGlzIGJvdGggc3luY2hyb25pemVkIGFuZAoraW52YXJpYW50IGFzICJUU0Mtc2FmZSIgYW5k IGFueSBoYXJkd2FyZSBvbiB3aGljaCBUU0MgaXMgbm90IChvcgorbWF5IG5vdCByZW1haW4pIHN5 bmNocm9uaXplZCBhcyAiVFNDLXVuc2FmZSIuCisKK0FzIGEgcmVzdWx0IG9mIFRTQydzIHNvcmRp ZCBoaXN0b3J5LCB0d28gY2xhc3NlcyBvZiBhcHBsaWNhdGlvbnMgdXNlCitUU0M6IG9sZCBhcHBs aWNhdGlvbnMgZGVzaWduZWQgZm9yIHNpbmdsZSBwcm9jZXNzb3JzLCBhbmQgdGhlIG1vc3QgcmVj ZW50CitlbnRlcHJpc2UgYXBwbGljYXRpb25zIHdoaWNoIHJlcXVpcmUgaGlnaC1mcmVxdWVuY3kg aGlnaC1wcmVjaXNpb24KK3RpbWVzdGFtcGluZy4KKworV2Ugd2lsbCByZWZlciB0byBhcHBzIHRo YXQgbWlnaHQgYnJlYWsgaWYgcnVubmluZyBvbiBhIFRTQy11bnNhZmUKK21hY2hpbmUgYXMgIlRT Qy1zZW5zaXRpdmUiOyBhcHBzIHRoYXQgZG9uJ3QgdXNlIFRTQywgb3IgZG8gdXNlCitUU0MgYnV0 IHVzZSBpdCBpbiBhIHdheSB0aGF0IG1vbm90b25pY2l0eSBhbmQgZnJlcXVlbmN5IGludmFyaWFu Y2UKK2FyZSB1bmltcG9ydGFudCBhcyAiVFNDLXJlc2lsaWVudCIuCisKK1RoZSBlbWVyZ2VuY2Ug b2YgdmlydHVhbGl6YXRpb24gb25jZSBhZ2FpbiBjb21wbGljYXRlcyB0aGUgdXNhZ2Ugb2YKK1RT Qy4gIFdoZW4gZmVhdHVyZXMgc3VjaCBhcyBzYXZlL3Jlc3RvcmUgb3IgbGl2ZSBtaWdyYXRpb24g YXJlIGVtcGxveWVkLAorYSBndWVzdCBPUyBhbmQgYWxsIGl0cyBjdXJyZW50bHkgcnVubmluZyBh cHBsaWNhdGlvbnMgbWF5IGJlIGludmlzaWJseQordHJhbnNwb3J0ZWQgdG8gYW4gZW50aXJlbHkg ZGlmZmVyZW50IHBoeXNpY2FsIG1hY2hpbmUuICBXaGlsZSBUU0MKK21heSBiZSAic2FmZSIgb24g b25lIG1hY2hpbmUsIGl0IGlzIGVzc2VudGlhbGx5IGltcG9zc2libGUgdG8gcHJlY2lzZWx5Citz eW5jaHJvbml6ZSBUU0MgYWNyb3NzIGEgZGF0YSBjZW50ZXIgb3IgZXZlbiBhIHBvb2wgb2YgbWFj aGluZXMuICBBcworYSByZXN1bHQsIHdoZW4gcnVuIGluIGEgdmlydHVhbGl6ZWQgZW52aXJvbm1l bnQsIHJhcmUgYW5kIG9ic2N1cmUKKyJ0aW1lIGdvaW5nIGJhY2t3YXJkcyIgcHJvYmxlbXMgbWln aHQgb25jZSBhZ2FpbiBvY2N1ciBmb3IgdGhvc2UKK1RTQy1zZW5zaXRpdmUgYXBwbGljYXRpb25z LiAgV29yc2UsIGlmIGEgZ3Vlc3QgT1MgbW92ZXMgZnJvbSwgZm9yCitleGFtcGxlLCBhIDNHSHoK K21hY2hpbmUgdG8gYSAxLjVHSHogbWFjaGluZSwgYXR0ZW1wdHMgYnkgYW4gT1MvYXBwIHRvIG1l YXN1cmUgdGltZQoraW50ZXJ2YWxzIHdpdGggVFNDIG1heSB3aXRob3V0IG5vdGljZSBiZSBpbmNv cnJlY3QgYnkgYSBmYWN0b3Igb2YgdHdvLgorCitUaGUgcmR0c2MgKHJlYWQgdGltZXN0YW1wIGNv dW50ZXIpIGluc3RydWN0aW9uIGlzIHVzZWQgdG8gcmVhZCB0aGUKK1RTQyByZWdpc3Rlci4gIFRo ZSByZHRzY3AgaW5zdHJ1Y3Rpb24gaXMgYSB2YXJpYW50IG9mIHJkdHNjIG9uIHJlY2VudAorcHJv Y2Vzc29ycy4gIFdlIHJlZmVyIHRvIHRoZXNlIHRvZ2V0aGVyIGFzIHRoZSByZHRzYyBmYW1pbHkg b2YgaW5zdHJ1Y3Rpb25zLAorb3IganVzdCAicmR0c2MiLiAgSW5zdHJ1Y3Rpb25zIGluIHRoZSBy ZHRzYyBmYW1pbHkgYXJlIG5vbi1wcml2aWxlZ2VkLCBidXQKK3ByaXZpbGVnZWQgc29mdHdhcmUg bWF5IHNldCBhIGNwdWlkIGJpdCB0byBjYXVzZSBhbGwgcmR0c2MgZmFtaWx5CitpbnN0cnVjdGlv bnMgdG8gdHJhcC4gIFRoaXMgdHJhcCBjYW4gYmUgZGV0ZWN0ZWQgYnkgWGVuLCB3aGljaCBjYW4K K3RoZW4gdHJhbnNwYXJlbnRseSAiZW11bGF0ZSIgdGhlIHJlc3VsdHMgb2YgdGhlIHJkdHNjIGlu c3RydWN0aW9uIGFuZAorcmV0dXJuIGNvbnRyb2wgdG8gdGhlIGNvZGUgZm9sbG93aW5nIHRoZSBy ZHRzYyBpbnN0cnVjdGlvbi4KKworVG8gcHJvdmlkZSBhICJzYWZlIiBUU0MsIGkuZS4gdG8gZW5z dXJlIGJvdGggVFNDIG1vbm9udG9uaWNpdHkgYW5kIGEKK2ZpeGVkIHJhdGUsIFhlbiBwcm92aWRl cyByZHRzYyBlbXVsYXRpb24gd2hlbmV2ZXIgbmVjZXNzYXJ5IG9yIHdoZW4KK2V4cGxpY2l0bHkg c3BlY2lmaWVkIGJ5IGEgcGVyLVZNIGNvbmZpZ3VyYXRpb24gb3B0aW9uLiAgVFNDIGVtdWxhdGlv biBpcworcmVsYXRpdmVseSBzbG93IC0tIHJvdWdobHkgMTUtMjAgdGltZXMgc2xvd2VyIHRoYW4g dGhlIHJkdHNjIGluc3RydWN0aW9uCit3aGVuIGV4ZWN1dGVkIG5hdGl2ZWx5LiAgSG93ZXZlciwg ZXhjZXB0IHdoZW4gYW4gT1Mgb3IgYXBwbGljYXRpb24gdXNlcwordGhlIHJkdHNjIGluc3RydWN0 aW9uIGF0IGEgaGlnaCBmcmVxdWVuY3kgKGUuZy4gbW9yZSB0aGFuIGFib3V0IDEwLDAwMCB0aW1l cworcGVyIHNlY29uZCBwZXIgcHJvY2Vzc29yKSwgdGhpcyBwZXJmb3JtYW5jZSBkZWdyYWRhdGlv biBpcyBub3Qgbm90aWNhYmxlCisoaS5lLiA8MC4zJSkuICBBbmQsIFRTQyBlbXVsYXRpb24gaXMg bmVhcmx5IGFsd2F5cyBmYXN0ZXIgdGhhbgorT1MtcHJvdmlkZWQgYWx0ZXJuYXRpdmVzIChlLmcu IExpbnV4J3MgZ2V0dGltZW9mZGF5KS4gIEZvciBlbnZpcm9ubWVudHMKK3doZXJlIGl0IGlzIGNl cnRhaW4gdGhhdCBhbGwgYXBwcyBhcmUgVFNDLXJlc2lsaWVudCAoZS5nLgorIlRTQy1zYWZlbmVz cyIgaXMgbm90IG5lY2Vzc2FyeSkgYW5kIGhpZ2hlc3QgcGVyZm9ybWFuY2UgaXMgYQorcmVxdWly ZW1lbnQsIFRTQyBlbXVsYXRpb24gbWF5IGJlIGVudGlyZWx5IGRpc2FibGVkICh0c2NfbW9kZT09 MikuCisKK1RoZSBkZWZhdWx0IG1vZGUgKHRzY19tb2RlPT0wKSBjaGVja3MgVFNDLXNhZmVuZXNz IG9mIHRoZSB1bmRlcmx5aW5nCitoYXJkd2FyZSBvbiB3aGljaCB0aGUgdmlydHVhbCBtYWNoaW5l IGlzIGxhdW5jaGVkLiAgSWYgaXQgaXMKK1RTQy1zYWZlLCByZHRzYyB3aWxsIGV4ZWN1dGUgYXQg aGFyZHdhcmUgc3BlZWQ7IGlmIGl0IGlzIG5vdCwgcmR0c2MKK3dpbGwgYmUgZW11bGF0ZWQuICBP bmNlIGEgdmlydHVhbCBtYWNoaW5lIGlzIHNhdmUvcmVzdG9yZWQgb3IgbWlncmF0ZWQsCitob3dl dmVyLCB0aGVyZSBhcmUgdHdvIHBvc3NpYmlsaXRpZXM6ICBGb3IgYSBwYXJhdmlydHVhbGl6ZWQg KFBWKSBkb21haW4sCitUU0Mgd2lsbCBhbHdheXMgYmUgZW11bGF0ZWQuICBGb3IgYSBmdWxseS12 aXJ0dWFsaXplZCAoSFZNKSBkb21haW4sCitUU0MgcmVtYWlucyBuYXRpdmUgSUYgdGhlIHNvdXJj ZSBwaHlzaWNhbCBtYWNoaW5lIGFuZCB0YXJnZXQgcGh5c2ljYWwgbWFjaGluZQoraGF2ZSB0aGUg c2FtZSBUU0MgZnJlcXVlbmN5OyBlbHNlIFRTQyBpcyBlbXVsYXRlZC4gIE5vdGUgdGhhdCwgdGhv dWdoCitlbXVsYXRlZCwgdGhlICJhcHBhcmVudCIgVFNDIGZyZXF1ZW5jeSB3aWxsIGJlIHRoZSBU U0MgZnJlcXVlbmN5CitvZiB0aGUgaW5pdGlhbCBwaHlzaWNhbCBtYWNoaW5lLCBldmVuIGFmdGVy IG1pZ3JhdGlvbi4KKworRm9yIGVudmlyb25tZW50cyB3aGVyZSBib3RoIFRTQy1zYWZlbmVzcyBB TkQgaGlnaGVzdCBwZXJmb3JtYW5jZQorZXZlbiBhY3Jvc3MgbWlncmF0aW9uIGlzIGEgcmVxdWly ZW1lbnQsIGFwcGxpY2F0aW9uIGNvZGUgY2FuIGJlIHNwZWNpYWxseQorbW9kaWZpZWQgdG8gdXNl IGFuIGFsZ29yaXRobSBleHBsaWNpdGx5IGRlc2lnbmVkIGludG8gWGVuIGZvciB0aGlzIHB1cnBv c2UuCitUaGlzIG1vZGUgKHRzY19tb2RlPT0zKSBpcyBjYWxsZWQgUFZSRFRTQ1AsIGJlY2F1c2Ug aXQgcmVxdWlyZXMKK2FwcCBwYXJhdmlydHVhbGl6YXRpb24gKGF3YXJlbmVzcyBieSB0aGUgYXBw IHRoYXQgaXQgbWF5IGJlIHJ1bm5pbmcKK29uIHRvcCBvZiBYZW4pLCBhbmQgdXRpbGl6ZXMgYSB2 YXJpYXRpb24gb2YgdGhlIHJkdHNjIGluc3RydWN0aW9uCitjYWxsZWQgcmR0c2NwIHRoYXQgaXMg YXZhaWxhYmxlIG9uIG1vc3QgcmVjZW50IGdlbmVyYXRpb24gcHJvY2Vzc29ycy4KKyhUaGUgcmR0 c2NwIGluc3RydWN0aW9uIGRpZmZlcnMgZnJvbSB0aGUgcmR0c2MgaW5zdHJ1Y3Rpb24gaW4gdGhh dCBpdAorcmVhZHMgbm90IG9ubHkgdGhlIFRTQyBidXQgYW4gYWRkaXRpb25hbCByZWdpc3RlciBz ZXQgYnkgc3lzdGVtIHNvZnR3YXJlLikKK1doZW4gYSBwdnJkdHNjcC1tb2RpZmllZCBhcHAgaXMg cnVubmluZyBvbiBhIHByb2Nlc3NvciB0aGF0IGlzIGJvdGggVFNDLXNhZmUKK2FuZCBzdXBwb3J0 cyB0aGUgcmR0c2NwIGluc3RydWN0aW9uLCBpbmZvcm1hdGlvbiBjYW4gYmUgb2J0YWluZWQKK2Fi b3V0IG1pZ3JhdGlvbiBhbmQgVFNDIGZyZXF1ZW5jeS9vZmZzZXQgYWRqdXN0bWVudCB0byBhbGxv dyB0aGUKK3Zhc3QgbWFqb3JpdHkgb2YgdGltZXN0YW1wcyB0byBiZSBvYnRhaW5lZCBhdCB0b3Ag cGVyZm9ybWFuY2U7IHdoZW4KK3J1bm5pbmcgb24gYSBUU0MtdW5zYWZlIHByb2Nlc3NvciBvciBh IHByb2Nlc3NvciB0aGF0IGRvZXNuJ3Qgc3VwcG9ydAordGhlIHJkdHNjcCBpbnN0cnVjdGlvbiwg cmR0c2NwIGlzIGVtdWxhdGVkLgorCitQVlJEVFNDUCAodHNjX21vZGU9PTMpIGhhcyB0d28gbGlt aXRhdGlvbnMuICBGaXJzdCwgaXQgYXBwbGllcyB0bworYWxsIGFwcHMgcnVubmluZyBpbiB0aGlz IHZpcnR1YWwgbWFjaGluZS4gIFRoaXMgbWVhbnMgdGhhdCBhbGwKK2FwcHMgbXVzdCBlaXRoZXIg YmUgVFNDLXJlc2lsaWVudCBvciBwdnJkdHNjcC1tb2RpZmllZC4gIFNlY29uZCwKK2hpZ2hlc3Qg cGVyZm9ybWFuY2UgaXMgb25seSBvYnRhaW5lZCBvbiBUU0Mtc2FmZSBtYWNoaW5lcyB0aGF0Citz dXBwb3J0IHRoZSByZHRzY3AgaW5zdHJ1Y3Rpb247IHdoZW4gcnVubmluZyBvbiBvbGRlciBtYWNo aW5lcywKK3JkdHNjcCBpcyBlbXVsYXRlZCBhbmQgdGh1cyBzbG93ZXIuICBGb3IgbW9yZSBpbmZv cm1hdGlvbiBvbiBQVlJUU0NQLAorc2VlIGJlbG93LgorCitGaW5hbGx5LCB0c2NfbW9kZT09MSBh bHdheXMgZW5hYmxlcyBUU0MgZW11bGF0aW9uLCByZWdhcmRsZXNzIG9mCit0aGUgdW5kZXJseWlu ZyBwaHlzaWNhbCBoYXJkd2FyZS4gVGhlICJhcHBhcmVudCIgVFNDIGZyZXF1ZW5jeSB3aWxsCiti ZSB0aGUgVFNDIGZyZXF1ZW5jeSBvZiB0aGUgaW5pdGlhbCBwaHlzaWNhbCBtYWNoaW5lLCBldmVu IGFmdGVyIG1pZ3JhdGlvbi4KK1RoaXMgbW9kZSBpcyB1c2VmdWwgdG8gbWVhc3VyZSBhbnkgcGVy Zm9ybWFuY2UgZGVncmFkYXRpb24gdGhhdAorbWlnaHQgYmUgZW5jb3VudGVyZWQgYnkgYSB0c2Nf bW9kZT09MCBkb21haW4gYWZ0ZXIgbWlncmF0aW9uIG9jY3VycywKK29yIGEgdHNjX21vZGU9PTMg ZG9tYWluIHdoZW4gaXQgaXMgcnVubmluZyBvbiBUU0MtdW5zYWZlIGhhcmR3YXJlLgorCitOb3Rl IHRoYXQgd2hpbGUgWGVuIGVuc3VyZXMgdGhhdCBhbiBlbXVsYXRlZCBUU0MgaXMgInNhZmUiIGFj cm9zcyBtaWdyYXRpb24sCitpdCBkb2VzIG5vdCBlbnN1cmUgdGhhdCBpdCBjb250aW51ZXMgdG8g dGljayBhdCB0aGUgc2FtZSByYXRlIGR1cmluZwordGhlIGFjdHVhbCBtaWdyYXRpb24uICBBcyBh biBvdmVyc2ltcGxpZmllZCBleGFtcGxlLCBpZiBUU0MgaXMgdGlja2luZworb25jZSBwZXIgc2Vj b25kIGluIGEgZ3Vlc3QsIGFuZCB0aGUgZ3Vlc3QgaXMgc2F2ZWQgd2hlbiB0aGUgVFNDIGlzIDEw MDAsCit0aGVuIHJlc3RvcmVkIDMwIHNlY29uZHMgbGF0ZXIsIFRTQyBpcyBvbmx5IGd1YXJhbnRl ZWQgdG8gYmUgZ3JlYXRlcgordGhhbiBvciBlcXVhbCB0byAxMDAxLCBub3QgcHJlY2lzZWx5IDEw MzAuICBUaGlzIGhhcyBzb21lIE9TIGltcGxpY2F0aW9ucworYXMgd2lsbCBiZSBzZWVuIGluIHRo ZSBuZXh0IHNlY3Rpb24uCisKK1RTQyBJTlZBUklBTlQgQklUIGFuZCBOT19NSUdSQVRFCisKK1Jl bGF0ZWQgdG8gVFNDIGVtdWxhdGlvbiwgdGhlICJUU0MgSW52YXJpYW50IiBiaXQgaXMgYXJjaGl0 ZWN0dXJhbGx5IGRlZmluZWQKK2luIGEgY3B1aWQgYml0IG9uIHRoZSBtb3N0IHJlY2VudCB4ODYg cHJvY2Vzc29ycy4gIElmIHNldCwgVFNDIGludmFyaWFuY2UKK2Vuc3VyZXMgdGhhdCB0aGUgVFND IGlzICJzYWZlIiwgdGhhdCBpcyBpdCB3aWxsIGluY3JlbWVudCBhdCBhIGNvbnN0YW50IHJhdGUK K3JlZ2FyZGxlc3Mgb2YgcG93ZXIgZXZlbnRzLCB3aWxsIGJlIHN5bmNocm9uaXplZCBhY3Jvc3Mg YWxsIHByb2Nlc3NvcnMsIGFuZAord2FzIHByb3Blcmx5IGluaXRpYWxpemVkIHRvIHplcm8gb24g YWxsIHByb2Nlc3NvcnMgYXQgYm9vdC10aW1lCitieSBzeXN0ZW0gaGFyZHdhcmUvQklPUy4gIEFz IGxvbmcgYXMgc3lzdGVtIHNvZnR3YXJlIG5ldmVyIHdyaXRlcyB0byBUU0MsCitUU0Mgd2lsbCBi ZSBzYWZlIGFuZCBjb250aW51b3VzbHkgaW5jcmVtZW50ZWQgYXQgYSBmaXhlZCByYXRlIGFuZCB0 aHVzCitjYW4gYmUgdXNlZCBhcyBhIHN5c3RlbSAiY2xvY2tzb3VyY2UiLgorCitUaGlzIGJpdCBp cyB1c2VkIGJ5IHNvbWUgT1MncywgYW5kIHNwZWNpZmljYWxseSBieSBMaW51eCBzdGFydGluZyB3 aXRoCit2ZXJzaW9uIDIuNi4zMCg/KSwgdG8gc2VsZWN0IFRTQyBhcyBhIHN5c3RlbSBjbG9ja3Nv dXJjZS4gIE9uY2Ugc2VsZWN0ZWQsCitUU0MgcmVtYWlucyB0aGUgTGludXggc3lzdGVtIGNsb2Nr c291cmNlIHVubGVzcyBtYW51YWxseSBvdmVycmlkZGVuLiAgSW4KK2EgdmlydHVhbGl6ZWQgZW52 aXJvbm1lbnQsIHNpbmNlIGl0IGlzIG5vdCBwb3NzaWJsZSB0byBzeW5jaHJvbml6ZSBUU0MKK2Fj cm9zcyBhbGwgdGhlIG1hY2hpbmVzIGluIGEgcG9vbCBvciBkYXRhIGNlbnRlciwgYSBtaWdyYXRp b24gbWF5ICJicmVhayIKK1RTQyBhcyBhIHVzYWJsZSBjbG9ja3NvdXJjZTsgd2hpbGUgdGltZSB3 aWxsIG5vdCBnbyBiYWNrd2FyZHMsIGl0IG1heQorbm90IHRyYWNrIHdhbGxjbG9jayB0aW1lIHdl bGwgZW5vdWdoIHRvIGF2b2lkIGNlcnRhaW4gdGltZS1zZW5zaXRpdmUKK2NvbnNlcXVlbmNlcy4g IEFzIGEgcmVzdWx0LCBYZW4gY2FuIG9ubHkgZXhwb3NlIHRoZSBUU0MgSW52YXJpYW50IGJpdAor dG8gYSBndWVzdCBPUyBpZiBpdCBpcyBjZXJ0YWluIHRoYXQgdGhlIGRvbWFpbiB3aWxsIG5ldmVy IG1pZ3JhdGUuCitBcyBvZiBYZW4gNC4wLCB0aGUgIm5vX21pZ3JhdGU9MSIgVk0gY29uZmlndXJh dGlvbiBvcHRpb24gbWF5IGJlIHNwZWNpZmllZAordG8gZGlzYWJsZSBtaWdyYXRpb24uICBJZiBu b19taWdyYXRlIGlzIHNlbGVjdGVkIGFuZCB0aGUgVk0gaXMgcnVubmluZworb24gYSBwaHlzaWNh bCBtYWNoaW5lIHdpdGggIlRTQyBJbnZhcmlhbnQiLCBMaW51eCAyLjYuMzArIHdpbGwgc2FmZWx5 Cit1c2UgVFNDIGFzIHRoZSBzeXN0ZW0gY2xvY2tzb3VyY2UuICBCdXQsIGF0dGVtcHRzIHRvIG1p Z3JhdGUgb3IsIG9uY2UKK3NhdmVkLCByZXN0b3JlIHRoaXMgZG9tYWluIHdpbGwgZmFpbC4KKwor VGhlcmUgaXMgYW5vdGhlciBjcHVpZC1yZWxhdGVkIGNvbXBsaWNhdGlvbjogVGhlIHg4NiBjcHVp ZCBpbnN0cnVjdGlvbiBpcworbm9uLXByaXZpbGVnZWQuICBIVk0gZG9tYWlucyBhcmUgY29uZmln dXJlZCB0byBhbHdheXMgdHJhcCB0aGlzIGluc3RydWN0aW9uCit0byBYZW4sIHdoZXJlIFhlbiBj YW4gImZpbHRlciIgdGhlIHJlc3VsdC4gIEluIGEgUFYgT1MsIGFsbCBjcHVpZCBpbnN0cnVjdGlv bnMKK2hhdmUgYmVlbiByZXBsYWNlZCBieSBhIHBhcnZpcnR1YWxpemVkIGVxdWl2YWxlbnQgb2Yg dGhlIGNwdWlkIGluc3RydWN0aW9uCisoInB2Y3B1aWQiKSBhbmQgYWxzbyB0cmFwIHRvIFhlbi4g IEJ1dCBhcHBzIGluIGEgUFYgZ3Vlc3QgdGhhdCB1c2UgYQorY3B1aWQgaW5zdHJ1Y3Rpb24gZXhl Y3V0ZSBpdCBkaXJlY3RseSwgd2l0aG91dCBhIHRyYXAgdG8gWGVuLiAgQXMgYSByZXN1bHQsCith biBhcHAgbWF5IGRpcmVjdGx5IGV4YW1pbmUgdGhlIHBoeXNpY2FsIFRTQyBJbnZhcmlhbnQgY3B1 aWQgYml0IGFuZCBtYWtlCitkZWNpc2lvbnMgYmFzZWQgb24gdGhhdCBiaXQuICBUaGlzIGlzIHN0 aWxsIGFuIHVuc29sdmVkIHByb2JsZW0sIHRob3VnaAorYSB3b3JrYXJvdW5kIGV4aXN0cyBhcyBw YXJ0IG9mIHRoZSBQVlJEVFNDUCB0c2NfbW9kZSBmb3IgYXBwcyB0aGF0CitjYW4gYmUgbW9kaWZp ZWQuCisKK01PUkUgT04gUFZSRFRTQ1AKKworUGFyYXZpcnR1YWxpemVkIE9TJ3MgdXNlIHRoZSAi cHZjbG9jayIgYWxnb3JpdGhtIHRvIG1hbmFnZSB0aGUgcGFzc2luZworb2YgdGltZS4gIFRoaXMg c29waGlzdGljYXRlZCBhbGdvcml0aG0gb2J0YWlucyBpbmZvcm1hdGlvbiBmcm9tIGEgbWVtb3J5 CitwYWdlIHNoYXJlZCBiZXR3ZWVuIFhlbiBhbmQgdGhlIE9TIGFuZCBzZWxlY3RzIGluZm9ybWF0 aW9uIGZyb20gdGhpcworcGFnZSBiYXNlZCBvbiB0aGUgY3VycmVudCB2aXJ0dWFsIENQVSAodmNw dSkgaW4gb3JkZXIgdG8gcHJvcGVybHkgYWRhcHQgdG8KK1RTQy11bnNhZmUgc3lzdGVtcyBhbmQg Y2hhbmdlcyB0aGF0IG9jY3VyIGFjcm9zcyBtaWdyYXRpb24uICBOZWl0aGVyCit0aGlzIHNoYXJl ZCBwYWdlIG5vciB0aGUgdmNwdSBpbmZvcm1hdGlvbiBpcyBhdmFpbGFibGUgdG8gYSB1c2VybGFu ZAorYXBwIHNvIHRoZSBwdmNsb2NrIGFsZ29yaXRobSBjYW5ub3QgYmUgZGlyZWN0bHkgdXNlZCBi eSBhbiBhcHAsIGF0IGxlYXN0Cit3aXRob3V0IHBlcmZvcm1hbmNlIGRlZ3JhZGF0aW9uIHJvdWdo bHkgZXF1YWwgdG8gdGhlIGNvc3Qgb2YganVzdAorZW11bGF0aW5nIGFuIHJkdHNjLgorCitBcyBh IHJlc3VsdCwgYXMgb2YgNC4wLCBYZW4gcHJvdmlkZXMgY2FwYWJpbGl0aWVzIGZvciBhIHVzZXJs YW5kIGFwcAordG8gb2J0YWluIGtleSB0aW1lIHZhbHVlcyBzaW1pbGFyIHRvIHRoZSBpbmZvcm1h dGlvbiBhY2Nlc3NpYmxlCit0byB0aGUgUFYgT1MgcHZjbG9jayBhbGdvcml0aG0uICBUaGUgYXBw IHVzZXMgdGhlIHJkdHNjcCBpbnN0cnVjdGlvbgord2hpY2ggaXMgZGVmaW5lZCBpbiByZWNlbnQg cHJvY2Vzc29ycyB0byBvYnRhaW4gYm90aCB0aGUgVFNDIGFuZCBhbgorYXV4aWxpYXJ5IHZhbHVl IGNhbGxlZCBUU0NfQVVYLiAgWGVuIGlzIHJlc3BvbnNpYmxlIGZvciBzZXR0aW5nIFRTQ19BVVgK K3RvIHRoZSBzYW1lIHZhbHVlIG9uIGFsbCB2Y3B1cyBydW5uaW5nIGFueSBkb21haW4gd2l0aCB0 c2NfbW9kZT09MzsKK2Z1cnRoZXIsIFhlbiB0b29scyBhcmUgcmVzcG9uc2libGUgZm9yIG1vbm90 b25pY2FsbHkgaW5jcmVtZW50aW5nIFRTQ19BVVgKK2FueXRpbWUgdGhlIGRvbWFpbiBpcyByZXN0 b3JlZC9taWdyYXRlZCAodGh1cyBjaGFuZ2luZyBrZXkgdGltZSB2YWx1ZXMpOworYW5kLCB3aGVu IHRoZSBkb21haW4gaXMgcnVubmluZyBvbiBhIHBoeXNpY2FsIG1hY2hpbmUgdGhhdCBlaXRoZXIK K2lzIG5vdCBUU0Mtc2FmZSBvciBkb2VzIG5vdCBzdXBwb3J0IHRoZSByZHRzY3AgaW5zdHJ1Y3Rp b24sIFhlbgoraXMgcmVzcG9uc2libGUgZm9yIGVtdWxhdGluZyB0aGUgcmR0c2NwIGluc3RydWN0 aW9uIGFuZCBmb3Igc2V0dGluZworVFNDX0FVWCB0byB6ZXJvIG9uIGFsbCBwcm9jZXNzb3JzLgor CitYZW4gYWxzbyBwcm92aWRlcyBwdmNsb2NrIGluZm9ybWF0aW9uIHZpYSBhICJwdmNwdWlkIiBp bnN0cnVjdGlvbi4KK1doaWxlIHRoaXMgcmVzdWx0cyBpbiBhIHNsb3cgdHJhcCwgdGhlIGluZm9y bWF0aW9uIGNoYW5nZXMKKyhhbmQgdGh1cyBtdXN0IGJlIHJlb2J0YWluZWQgdmlhIHB2Y3B1aWQp IE9OTFkgd2hlbiBUU0NfQVVYCitoYXMgY2hhbmdlZCwgd2hpY2ggc2hvdWxkIGJlIHZlcnkgcmFy ZSByZWxhdGl2ZSB0byBhIGhpZ2gKK2ZyZXF1ZW5jeSBvZiByZHRzY3AgaW5zdHJ1Y3Rpb25zLgor CitGaW5hbGx5LCBYZW4gcHJvdmlkZXMgYWRkaXRpb25hbCB0aW1lLXJlbGF0ZWQgaW5mb3JtYXRp b24gdmlhCitvdGhlciBwdmNwdWlkIGluc3RydWN0aW9ucy4gIEZpcnN0LCBhbiBhcHAgaXMgY2Fw YWJsZSBvZgorZGV0ZXJtaW5pbmcgaWYgaXQgaXMgY3VycmVudGx5IHJ1bm5pbmcgb24gWGVuLCBu ZXh0IHdoZXRoZXIKK3RoZSB0c2NfbW9kZSBzZXR0aW5nIG9mIHRoZSBkb21haW4gaW4gd2hpY2gg aXQgaXMgcnVubmluZywKK2FuZCBmaW5hbGx5IHdoZXRoZXIgdGhlIHVuZGVybHlpbmcgaGFyZHdh cmUgaXMgVFNDLXNhZmUgYW5kCitzdXBwb3J0cyB0aGUgcmR0c2NwIGluc3RydWN0aW9uLgorCitB cyBhIHJlc3VsdCwgYSBwdnJkdHNjcC1tb2RpZmllZCBhcHAgaGFzIHN1ZmZpY2llbnQgaW5mb3Jt YXRpb24KK3RvIGNvbXB1dGUgdGhlIHB2Y2xvY2sgImVsYXBzZWQgbmFub3NlY29uZHMiIHdoaWNo IGNhbgorYmUgdXNlZCBhcyBhIHRpbWVzdGFtcC4gIEFuZCB0aGlzIGNhbiBiZSBkb25lIG5lYXJs eSBhcworZmFzdCBhcyBhIG5hdGl2ZSByZHRzYyBpbnN0cnVjdGlvbiwgbXVjaCBmYXN0ZXIgdGhh biBlbXVsYXRpb24sCithbmQgYWxzbyBtdWNoIGZhc3RlciB0aGFuIG5lYXJseSBhbGwgT1MtcHJv dmlkZWQgdGltZSBtZWNoYW5pc21zLgorV2hpbGUgcHZydHNjcCBpcyB0b28gY29tcGxleCBmb3Ig bW9zdCBhcHBzLCBjZXJ0YWluIGVudGVycHJpc2UKK1RTQy1zZW5zaXRpdmUgaGlnaC1UU0MtZnJl cXVlbmN5IGFwcHMgbWF5IGZpbmQgaXQgdXNlZnVsIHRvCitvYnRhaW4gYSBzaWduaWZpY2FudCBw ZXJmb3JtYW5jZSBnYWluLgo= --__125969202969068996abhmt003.oracle.com Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Xen-devel mailing list Xen-devel@lists.xensource.com http://lists.xensource.com/xen-devel --__125969202969068996abhmt003.oracle.com--