From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:54059) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1cnZoy-0000LV-FL for qemu-devel@nongnu.org; Mon, 13 Mar 2017 19:56:15 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1cnZow-0004kX-1W for qemu-devel@nongnu.org; Mon, 13 Mar 2017 19:56:12 -0400 Received: from mail.kernel.org ([198.145.29.136]:46710) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1cnZov-0004jx-Jm for qemu-devel@nongnu.org; Mon, 13 Mar 2017 19:56:09 -0400 From: Stefano Stabellini Date: Mon, 13 Mar 2017 16:55:53 -0700 Message-Id: <1489449360-14411-2-git-send-email-sstabellini@kernel.org> In-Reply-To: <1489449360-14411-1-git-send-email-sstabellini@kernel.org> References: <1489449360-14411-1-git-send-email-sstabellini@kernel.org> Subject: [Qemu-devel] [PATCH v2 2/9] xen: import ring.h from xen List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: xen-devel@lists.xenproject.org, sstabellini@kernel.org, anthony.perard@citrix.com, groug@kaod.org, Stefano Stabellini , jgross@suse.com Do not use the ring.h header installed on the system. Instead, import the header into the QEMU codebase. This avoids problems when QEMU is built against a Xen version too old to provide all the ring macros. Signed-off-by: Stefano Stabellini CC: anthony.perard@citrix.com CC: jgross@suse.com --- NB: The new macros have not been committed to Xen yet. Do not apply this patch until they do. --- --- hw/block/xen_blkif.h | 2 +- hw/usb/xen-usb.c | 2 +- include/hw/xen/io/ring.h | 455 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 457 insertions(+), 2 deletions(-) create mode 100644 include/hw/xen/io/ring.h diff --git a/hw/block/xen_blkif.h b/hw/block/xen_blkif.h index 3300b6f..3e6e1ea 100644 --- a/hw/block/xen_blkif.h +++ b/hw/block/xen_blkif.h @@ -1,7 +1,7 @@ #ifndef XEN_BLKIF_H #define XEN_BLKIF_H -#include +#include "hw/xen/io/ring.h" #include #include diff --git a/hw/usb/xen-usb.c b/hw/usb/xen-usb.c index 8e676e6..370b3d9 100644 --- a/hw/usb/xen-usb.c +++ b/hw/usb/xen-usb.c @@ -33,7 +33,7 @@ #include "qapi/qmp/qint.h" #include "qapi/qmp/qstring.h" -#include +#include "hw/xen/io/ring.h" #include /* diff --git a/include/hw/xen/io/ring.h b/include/hw/xen/io/ring.h new file mode 100644 index 0000000..cf01fc3 --- /dev/null +++ b/include/hw/xen/io/ring.h @@ -0,0 +1,455 @@ +/****************************************************************************** + * ring.h + * + * Shared producer-consumer ring macros. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Tim Deegan and Andrew Warfield November 2004. + */ + +#ifndef __XEN_PUBLIC_IO_RING_H__ +#define __XEN_PUBLIC_IO_RING_H__ + +#if __XEN_INTERFACE_VERSION__ < 0x00030208 +#define xen_mb() mb() +#define xen_rmb() rmb() +#define xen_wmb() wmb() +#endif + +typedef unsigned int RING_IDX; + +/* Round a 32-bit unsigned constant down to the nearest power of two. */ +#define __RD2(_x) (((_x) & 0x00000002) ? 0x2 : ((_x) & 0x1)) +#define __RD4(_x) (((_x) & 0x0000000c) ? __RD2((_x)>>2)<<2 : __RD2(_x)) +#define __RD8(_x) (((_x) & 0x000000f0) ? __RD4((_x)>>4)<<4 : __RD4(_x)) +#define __RD16(_x) (((_x) & 0x0000ff00) ? __RD8((_x)>>8)<<8 : __RD8(_x)) +#define __RD32(_x) (((_x) & 0xffff0000) ? __RD16((_x)>>16)<<16 : __RD16(_x)) + +/* + * Calculate size of a shared ring, given the total available space for the + * ring and indexes (_sz), and the name tag of the request/response structure. + * A ring contains as many entries as will fit, rounded down to the nearest + * power of two (so we can mask with (size-1) to loop around). + */ +#define __CONST_RING_SIZE(_s, _sz) \ + (__RD32(((_sz) - offsetof(struct _s##_sring, ring)) / \ + sizeof(((struct _s##_sring *)0)->ring[0]))) +/* + * The same for passing in an actual pointer instead of a name tag. + */ +#define __RING_SIZE(_s, _sz) \ + (__RD32(((_sz) - (long)(_s)->ring + (long)(_s)) / sizeof((_s)->ring[0]))) + +/* + * Macros to make the correct C datatypes for a new kind of ring. + * + * To make a new ring datatype, you need to have two message structures, + * let's say request_t, and response_t already defined. + * + * In a header where you want the ring datatype declared, you then do: + * + * DEFINE_RING_TYPES(mytag, request_t, response_t); + * + * These expand out to give you a set of types, as you can see below. + * The most important of these are: + * + * mytag_sring_t - The shared ring. + * mytag_front_ring_t - The 'front' half of the ring. + * mytag_back_ring_t - The 'back' half of the ring. + * + * To initialize a ring in your code you need to know the location and size + * of the shared memory area (PAGE_SIZE, for instance). To initialise + * the front half: + * + * mytag_front_ring_t front_ring; + * SHARED_RING_INIT((mytag_sring_t *)shared_page); + * FRONT_RING_INIT(&front_ring, (mytag_sring_t *)shared_page, PAGE_SIZE); + * + * Initializing the back follows similarly (note that only the front + * initializes the shared ring): + * + * mytag_back_ring_t back_ring; + * BACK_RING_INIT(&back_ring, (mytag_sring_t *)shared_page, PAGE_SIZE); + */ + +#define DEFINE_RING_TYPES(__name, __req_t, __rsp_t) \ + \ +/* Shared ring entry */ \ +union __name##_sring_entry { \ + __req_t req; \ + __rsp_t rsp; \ +}; \ + \ +/* Shared ring page */ \ +struct __name##_sring { \ + RING_IDX req_prod, req_event; \ + RING_IDX rsp_prod, rsp_event; \ + union { \ + struct { \ + uint8_t smartpoll_active; \ + } netif; \ + struct { \ + uint8_t msg; \ + } tapif_user; \ + uint8_t pvt_pad[4]; \ + } pvt; \ + uint8_t __pad[44]; \ + union __name##_sring_entry ring[1]; /* variable-length */ \ +}; \ + \ +/* "Front" end's private variables */ \ +struct __name##_front_ring { \ + RING_IDX req_prod_pvt; \ + RING_IDX rsp_cons; \ + unsigned int nr_ents; \ + struct __name##_sring *sring; \ +}; \ + \ +/* "Back" end's private variables */ \ +struct __name##_back_ring { \ + RING_IDX rsp_prod_pvt; \ + RING_IDX req_cons; \ + unsigned int nr_ents; \ + struct __name##_sring *sring; \ +}; \ + \ +/* Syntactic sugar */ \ +typedef struct __name##_sring __name##_sring_t; \ +typedef struct __name##_front_ring __name##_front_ring_t; \ +typedef struct __name##_back_ring __name##_back_ring_t + +/* + * Macros for manipulating rings. + * + * FRONT_RING_whatever works on the "front end" of a ring: here + * requests are pushed on to the ring and responses taken off it. + * + * BACK_RING_whatever works on the "back end" of a ring: here + * requests are taken off the ring and responses put on. + * + * N.B. these macros do NO INTERLOCKS OR FLOW CONTROL. + * This is OK in 1-for-1 request-response situations where the + * requestor (front end) never has more than RING_SIZE()-1 + * outstanding requests. + */ + +/* Initialising empty rings */ +#define SHARED_RING_INIT(_s) do { \ + (_s)->req_prod = (_s)->rsp_prod = 0; \ + (_s)->req_event = (_s)->rsp_event = 1; \ + (void)memset((_s)->pvt.pvt_pad, 0, sizeof((_s)->pvt.pvt_pad)); \ + (void)memset((_s)->__pad, 0, sizeof((_s)->__pad)); \ +} while(0) + +#define FRONT_RING_INIT(_r, _s, __size) do { \ + (_r)->req_prod_pvt = 0; \ + (_r)->rsp_cons = 0; \ + (_r)->nr_ents = __RING_SIZE(_s, __size); \ + (_r)->sring = (_s); \ +} while (0) + +#define BACK_RING_INIT(_r, _s, __size) do { \ + (_r)->rsp_prod_pvt = 0; \ + (_r)->req_cons = 0; \ + (_r)->nr_ents = __RING_SIZE(_s, __size); \ + (_r)->sring = (_s); \ +} while (0) + +/* How big is this ring? */ +#define RING_SIZE(_r) \ + ((_r)->nr_ents) + +/* Number of free requests (for use on front side only). */ +#define RING_FREE_REQUESTS(_r) \ + (RING_SIZE(_r) - ((_r)->req_prod_pvt - (_r)->rsp_cons)) + +/* Test if there is an empty slot available on the front ring. + * (This is only meaningful from the front. ) + */ +#define RING_FULL(_r) \ + (RING_FREE_REQUESTS(_r) == 0) + +/* Test if there are outstanding messages to be processed on a ring. */ +#define RING_HAS_UNCONSUMED_RESPONSES(_r) \ + ((_r)->sring->rsp_prod - (_r)->rsp_cons) + +#ifdef __GNUC__ +#define RING_HAS_UNCONSUMED_REQUESTS(_r) ({ \ + unsigned int req = (_r)->sring->req_prod - (_r)->req_cons; \ + unsigned int rsp = RING_SIZE(_r) - \ + ((_r)->req_cons - (_r)->rsp_prod_pvt); \ + req < rsp ? req : rsp; \ +}) +#else +/* Same as above, but without the nice GCC ({ ... }) syntax. */ +#define RING_HAS_UNCONSUMED_REQUESTS(_r) \ + ((((_r)->sring->req_prod - (_r)->req_cons) < \ + (RING_SIZE(_r) - ((_r)->req_cons - (_r)->rsp_prod_pvt))) ? \ + ((_r)->sring->req_prod - (_r)->req_cons) : \ + (RING_SIZE(_r) - ((_r)->req_cons - (_r)->rsp_prod_pvt))) +#endif + +/* Direct access to individual ring elements, by index. */ +#define RING_GET_REQUEST(_r, _idx) \ + (&((_r)->sring->ring[((_idx) & (RING_SIZE(_r) - 1))].req)) + +/* + * Get a local copy of a request. + * + * Use this in preference to RING_GET_REQUEST() so all processing is + * done on a local copy that cannot be modified by the other end. + * + * Note that https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58145 may cause this + * to be ineffective where _req is a struct which consists of only bitfields. + */ +#define RING_COPY_REQUEST(_r, _idx, _req) do { \ + /* Use volatile to force the copy into _req. */ \ + *(_req) = *(volatile typeof(_req))RING_GET_REQUEST(_r, _idx); \ +} while (0) + +#define RING_GET_RESPONSE(_r, _idx) \ + (&((_r)->sring->ring[((_idx) & (RING_SIZE(_r) - 1))].rsp)) + +/* Loop termination condition: Would the specified index overflow the ring? */ +#define RING_REQUEST_CONS_OVERFLOW(_r, _cons) \ + (((_cons) - (_r)->rsp_prod_pvt) >= RING_SIZE(_r)) + +/* Ill-behaved frontend determination: Can there be this many requests? */ +#define RING_REQUEST_PROD_OVERFLOW(_r, _prod) \ + (((_prod) - (_r)->rsp_prod_pvt) > RING_SIZE(_r)) + +#define RING_PUSH_REQUESTS(_r) do { \ + xen_wmb(); /* back sees requests /before/ updated producer index */ \ + (_r)->sring->req_prod = (_r)->req_prod_pvt; \ +} while (0) + +#define RING_PUSH_RESPONSES(_r) do { \ + xen_wmb(); /* front sees resps /before/ updated producer index */ \ + (_r)->sring->rsp_prod = (_r)->rsp_prod_pvt; \ +} while (0) + +/* + * Notification hold-off (req_event and rsp_event): + * + * When queueing requests or responses on a shared ring, it may not always be + * necessary to notify the remote end. For example, if requests are in flight + * in a backend, the front may be able to queue further requests without + * notifying the back (if the back checks for new requests when it queues + * responses). + * + * When enqueuing requests or responses: + * + * Use RING_PUSH_{REQUESTS,RESPONSES}_AND_CHECK_NOTIFY(). The second argument + * is a boolean return value. True indicates that the receiver requires an + * asynchronous notification. + * + * After dequeuing requests or responses (before sleeping the connection): + * + * Use RING_FINAL_CHECK_FOR_REQUESTS() or RING_FINAL_CHECK_FOR_RESPONSES(). + * The second argument is a boolean return value. True indicates that there + * are pending messages on the ring (i.e., the connection should not be put + * to sleep). + * + * These macros will set the req_event/rsp_event field to trigger a + * notification on the very next message that is enqueued. If you want to + * create batches of work (i.e., only receive a notification after several + * messages have been enqueued) then you will need to create a customised + * version of the FINAL_CHECK macro in your own code, which sets the event + * field appropriately. + */ + +#define RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(_r, _notify) do { \ + RING_IDX __old = (_r)->sring->req_prod; \ + RING_IDX __new = (_r)->req_prod_pvt; \ + xen_wmb(); /* back sees requests /before/ updated producer index */ \ + (_r)->sring->req_prod = __new; \ + xen_mb(); /* back sees new requests /before/ we check req_event */ \ + (_notify) = ((RING_IDX)(__new - (_r)->sring->req_event) < \ + (RING_IDX)(__new - __old)); \ +} while (0) + +#define RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(_r, _notify) do { \ + RING_IDX __old = (_r)->sring->rsp_prod; \ + RING_IDX __new = (_r)->rsp_prod_pvt; \ + xen_wmb(); /* front sees resps /before/ updated producer index */ \ + (_r)->sring->rsp_prod = __new; \ + xen_mb(); /* front sees new resps /before/ we check rsp_event */ \ + (_notify) = ((RING_IDX)(__new - (_r)->sring->rsp_event) < \ + (RING_IDX)(__new - __old)); \ +} while (0) + +#define RING_FINAL_CHECK_FOR_REQUESTS(_r, _work_to_do) do { \ + (_work_to_do) = RING_HAS_UNCONSUMED_REQUESTS(_r); \ + if (_work_to_do) break; \ + (_r)->sring->req_event = (_r)->req_cons + 1; \ + xen_mb(); \ + (_work_to_do) = RING_HAS_UNCONSUMED_REQUESTS(_r); \ +} while (0) + +#define RING_FINAL_CHECK_FOR_RESPONSES(_r, _work_to_do) do { \ + (_work_to_do) = RING_HAS_UNCONSUMED_RESPONSES(_r); \ + if (_work_to_do) break; \ + (_r)->sring->rsp_event = (_r)->rsp_cons + 1; \ + xen_mb(); \ + (_work_to_do) = RING_HAS_UNCONSUMED_RESPONSES(_r); \ +} while (0) + + +/* + * DEFINE_XEN_FLEX_RING_AND_INTF defines two monodirectional rings and + * functions to check if there is data on the ring, and to read and + * write to them. + * + * DEFINE_XEN_FLEX_RING is similar to DEFINE_XEN_FLEX_RING_AND_INTF, but + * does not define the indexes page. As different protocols can have + * extensions to the basic format, this macro allow them to define their + * own struct. + * + * XEN_FLEX_RING_SIZE + * Convenience macro to calculate the size of one of the two rings + * from the overall order. + * + * $NAME_mask + * Function to apply the size mask to an index, to reduce the index + * within the range [0-size]. + * + * $NAME_read_packet + * Function to read data from the ring. The amount of data to read is + * specified by the "size" argument. + * + * $NAME_write_packet + * Function to write data to the ring. The amount of data to write is + * specified by the "size" argument. + * + * $NAME_get_ring_ptr + * Convenience function that returns a pointer to read/write to the + * ring at the right location. + * + * $NAME_data_intf + * Indexes page, shared between frontend and backend. It also + * contains the array of grant refs. + * + * $NAME_queued + * Function to calculate how many bytes are currently on the ring, + * ready to be read. It can also be used to calculate how much free + * space is currently on the ring (ring_size - $NAME_queued()). + */ +#define XEN_FLEX_RING_SIZE(order) \ + (1UL << (order + PAGE_SHIFT - 1)) + +#define DEFINE_XEN_FLEX_RING_AND_INTF(name) \ +struct name##_data_intf { \ + RING_IDX in_cons, in_prod; \ + \ + uint8_t pad1[56]; \ + \ + RING_IDX out_cons, out_prod; \ + \ + uint8_t pad2[56]; \ + \ + RING_IDX ring_order; \ + grant_ref_t ref[]; \ +}; \ +DEFINE_XEN_FLEX_RING(name); + +#define DEFINE_XEN_FLEX_RING(name) \ +static inline RING_IDX name##_mask(RING_IDX idx, RING_IDX ring_size) \ +{ \ + return (idx & (ring_size - 1)); \ +} \ + \ +static inline RING_IDX name##_mask_order(RING_IDX idx, RING_IDX ring_order) \ +{ \ + return (idx & (XEN_FLEX_RING_SIZE(ring_order) - 1)); \ +} \ + \ +static inline unsigned char* name##_get_ring_ptr(unsigned char *buf, \ + RING_IDX idx, \ + RING_IDX ring_order) \ +{ \ + return buf + name##_mask_order(idx, ring_order); \ +} \ + \ +static inline void name##_read_packet(const unsigned char *buf, \ + RING_IDX masked_prod, RING_IDX *masked_cons, \ + RING_IDX ring_size, void *opaque, size_t size) { \ + if (*masked_cons < masked_prod || \ + size <= ring_size - *masked_cons) { \ + memcpy(opaque, buf + *masked_cons, size); \ + } else { \ + memcpy(opaque, buf + *masked_cons, ring_size - *masked_cons); \ + memcpy((unsigned char *)opaque + ring_size - *masked_cons, buf, \ + size - (ring_size - *masked_cons)); \ + } \ + *masked_cons = name##_mask(*masked_cons + size, ring_size); \ +} \ + \ +static inline void name##_write_packet(unsigned char *buf, \ + RING_IDX *masked_prod, RING_IDX masked_cons, \ + RING_IDX ring_size, const void *opaque, size_t size) { \ + if (*masked_prod < masked_cons || \ + size <= ring_size - *masked_prod) { \ + memcpy(buf + *masked_prod, opaque, size); \ + } else { \ + memcpy(buf + *masked_prod, opaque, ring_size - *masked_prod); \ + memcpy(buf, (unsigned char *)opaque + (ring_size - *masked_prod), \ + size - (ring_size - *masked_prod)); \ + } \ + *masked_prod = name##_mask(*masked_prod + size, ring_size); \ +} \ + \ +struct name##_data { \ + unsigned char *in; /* half of the allocation */ \ + unsigned char *out; /* half of the allocation */ \ +}; \ + \ + \ +static inline RING_IDX name##_queued(RING_IDX prod, \ + RING_IDX cons, RING_IDX ring_size) \ +{ \ + RING_IDX size; \ + \ + if (prod == cons) \ + return 0; \ + \ + prod = name##_mask(prod, ring_size); \ + cons = name##_mask(cons, ring_size); \ + \ + if (prod == cons) \ + return ring_size; \ + \ + if (prod > cons) \ + size = prod - cons; \ + else \ + size = ring_size - (cons - prod); \ + return size; \ +}; + +#endif /* __XEN_PUBLIC_IO_RING_H__ */ + +/* + * Local variables: + * mode: C + * c-file-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Stefano Stabellini Subject: [PATCH v2 2/9] xen: import ring.h from xen Date: Mon, 13 Mar 2017 16:55:53 -0700 Message-ID: <1489449360-14411-2-git-send-email-sstabellini@kernel.org> References: <1489449360-14411-1-git-send-email-sstabellini@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1cnZoy-0007sF-8c for xen-devel@lists.xenproject.org; Mon, 13 Mar 2017 23:56:12 +0000 In-Reply-To: <1489449360-14411-1-git-send-email-sstabellini@kernel.org> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: qemu-devel@nongnu.org Cc: jgross@suse.com, sstabellini@kernel.org, groug@kaod.org, Stefano Stabellini , anthony.perard@citrix.com, xen-devel@lists.xenproject.org List-Id: xen-devel@lists.xenproject.org RG8gbm90IHVzZSB0aGUgcmluZy5oIGhlYWRlciBpbnN0YWxsZWQgb24gdGhlIHN5c3RlbS4gSW5z dGVhZCwgaW1wb3J0CnRoZSBoZWFkZXIgaW50byB0aGUgUUVNVSBjb2RlYmFzZS4gVGhpcyBhdm9p ZHMgcHJvYmxlbXMgd2hlbiBRRU1VIGlzCmJ1aWx0IGFnYWluc3QgYSBYZW4gdmVyc2lvbiB0b28g b2xkIHRvIHByb3ZpZGUgYWxsIHRoZSByaW5nIG1hY3Jvcy4KClNpZ25lZC1vZmYtYnk6IFN0ZWZh bm8gU3RhYmVsbGluaSA8c3RlZmFub0BhcG9yZXRvLmNvbT4KQ0M6IGFudGhvbnkucGVyYXJkQGNp dHJpeC5jb20KQ0M6IGpncm9zc0BzdXNlLmNvbQotLS0KTkI6IFRoZSBuZXcgbWFjcm9zIGhhdmUg bm90IGJlZW4gY29tbWl0dGVkIHRvIFhlbiB5ZXQuIERvIG5vdCBhcHBseSB0aGlzCnBhdGNoIHVu dGlsIHRoZXkgZG8uCi0tLQotLS0KIGh3L2Jsb2NrL3hlbl9ibGtpZi5oICAgICB8ICAgMiArLQog aHcvdXNiL3hlbi11c2IuYyAgICAgICAgIHwgICAyICstCiBpbmNsdWRlL2h3L3hlbi9pby9yaW5n LmggfCA0NTUgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysK IDMgZmlsZXMgY2hhbmdlZCwgNDU3IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCiBjcmVh dGUgbW9kZSAxMDA2NDQgaW5jbHVkZS9ody94ZW4vaW8vcmluZy5oCgpkaWZmIC0tZ2l0IGEvaHcv YmxvY2sveGVuX2Jsa2lmLmggYi9ody9ibG9jay94ZW5fYmxraWYuaAppbmRleCAzMzAwYjZmLi4z ZTZlMWVhIDEwMDY0NAotLS0gYS9ody9ibG9jay94ZW5fYmxraWYuaAorKysgYi9ody9ibG9jay94 ZW5fYmxraWYuaApAQCAtMSw3ICsxLDcgQEAKICNpZm5kZWYgWEVOX0JMS0lGX0gKICNkZWZpbmUg WEVOX0JMS0lGX0gKIAotI2luY2x1ZGUgPHhlbi9pby9yaW5nLmg+CisjaW5jbHVkZSAiaHcveGVu L2lvL3JpbmcuaCIKICNpbmNsdWRlIDx4ZW4vaW8vYmxraWYuaD4KICNpbmNsdWRlIDx4ZW4vaW8v cHJvdG9jb2xzLmg+CiAKZGlmZiAtLWdpdCBhL2h3L3VzYi94ZW4tdXNiLmMgYi9ody91c2IveGVu LXVzYi5jCmluZGV4IDhlNjc2ZTYuLjM3MGIzZDkgMTAwNjQ0Ci0tLSBhL2h3L3VzYi94ZW4tdXNi LmMKKysrIGIvaHcvdXNiL3hlbi11c2IuYwpAQCAtMzMsNyArMzMsNyBAQAogI2luY2x1ZGUgInFh cGkvcW1wL3FpbnQuaCIKICNpbmNsdWRlICJxYXBpL3FtcC9xc3RyaW5nLmgiCiAKLSNpbmNsdWRl IDx4ZW4vaW8vcmluZy5oPgorI2luY2x1ZGUgImh3L3hlbi9pby9yaW5nLmgiCiAjaW5jbHVkZSA8 eGVuL2lvL3VzYmlmLmg+CiAKIC8qCmRpZmYgLS1naXQgYS9pbmNsdWRlL2h3L3hlbi9pby9yaW5n LmggYi9pbmNsdWRlL2h3L3hlbi9pby9yaW5nLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uY2YwMWZjMwotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvaHcveGVuL2lvL3Jp bmcuaApAQCAtMCwwICsxLDQ1NSBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogcmluZy5o CisgKiAKKyAqIFNoYXJlZCBwcm9kdWNlci1jb25zdW1lciByaW5nIG1hY3Jvcy4KKyAqCisgKiBQ ZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNv biBvYnRhaW5pbmcgYSBjb3B5CisgKiBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRv Y3VtZW50YXRpb24gZmlsZXMgKHRoZSAiU29mdHdhcmUiKSwgdG8KKyAqIGRlYWwgaW4gdGhlIFNv ZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24g dGhlCisgKiByaWdodHMgdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0 cmlidXRlLCBzdWJsaWNlbnNlLCBhbmQvb3IKKyAqIHNlbGwgY29waWVzIG9mIHRoZSBTb2Z0d2Fy ZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzCisgKiBmdXJu aXNoZWQgdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgorICoK KyAqIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNl IHNoYWxsIGJlIGluY2x1ZGVkIGluCisgKiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRp b25zIG9mIHRoZSBTb2Z0d2FyZS4KKyAqCisgKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFT IElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgorICogSU1QTElF RCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFksCisgKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5G UklOR0VNRU5ULiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUKKyAqIEFVVEhPUlMgT1IgQ09QWVJJR0hU IEhPTERFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVIKKyAqIExJ QUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJX SVNFLCBBUklTSU5HCisgKiBGUk9NLCBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBT T0ZUV0FSRSBPUiBUSEUgVVNFIE9SIE9USEVSCisgKiBERUFMSU5HUyBJTiBUSEUgU09GVFdBUkUu CisgKgorICogVGltIERlZWdhbiBhbmQgQW5kcmV3IFdhcmZpZWxkIE5vdmVtYmVyIDIwMDQuCisg Ki8KKworI2lmbmRlZiBfX1hFTl9QVUJMSUNfSU9fUklOR19IX18KKyNkZWZpbmUgX19YRU5fUFVC TElDX0lPX1JJTkdfSF9fCisKKyNpZiBfX1hFTl9JTlRFUkZBQ0VfVkVSU0lPTl9fIDwgMHgwMDAz MDIwOAorI2RlZmluZSB4ZW5fbWIoKSAgbWIoKQorI2RlZmluZSB4ZW5fcm1iKCkgcm1iKCkKKyNk ZWZpbmUgeGVuX3dtYigpIHdtYigpCisjZW5kaWYKKwordHlwZWRlZiB1bnNpZ25lZCBpbnQgUklO R19JRFg7CisKKy8qIFJvdW5kIGEgMzItYml0IHVuc2lnbmVkIGNvbnN0YW50IGRvd24gdG8gdGhl IG5lYXJlc3QgcG93ZXIgb2YgdHdvLiAqLworI2RlZmluZSBfX1JEMihfeCkgICgoKF94KSAmIDB4 MDAwMDAwMDIpID8gMHgyICAgICAgICAgICAgICAgICAgOiAoKF94KSAmIDB4MSkpCisjZGVmaW5l IF9fUkQ0KF94KSAgKCgoX3gpICYgMHgwMDAwMDAwYykgPyBfX1JEMigoX3gpPj4yKTw8MiAgICA6 IF9fUkQyKF94KSkKKyNkZWZpbmUgX19SRDgoX3gpICAoKChfeCkgJiAweDAwMDAwMGYwKSA/IF9f UkQ0KChfeCk+PjQpPDw0ICAgIDogX19SRDQoX3gpKQorI2RlZmluZSBfX1JEMTYoX3gpICgoKF94 KSAmIDB4MDAwMGZmMDApID8gX19SRDgoKF94KT4+OCk8PDggICAgOiBfX1JEOChfeCkpCisjZGVm aW5lIF9fUkQzMihfeCkgKCgoX3gpICYgMHhmZmZmMDAwMCkgPyBfX1JEMTYoKF94KT4+MTYpPDwx NiA6IF9fUkQxNihfeCkpCisKKy8qCisgKiBDYWxjdWxhdGUgc2l6ZSBvZiBhIHNoYXJlZCByaW5n LCBnaXZlbiB0aGUgdG90YWwgYXZhaWxhYmxlIHNwYWNlIGZvciB0aGUKKyAqIHJpbmcgYW5kIGlu ZGV4ZXMgKF9zeiksIGFuZCB0aGUgbmFtZSB0YWcgb2YgdGhlIHJlcXVlc3QvcmVzcG9uc2Ugc3Ry dWN0dXJlLgorICogQSByaW5nIGNvbnRhaW5zIGFzIG1hbnkgZW50cmllcyBhcyB3aWxsIGZpdCwg cm91bmRlZCBkb3duIHRvIHRoZSBuZWFyZXN0IAorICogcG93ZXIgb2YgdHdvIChzbyB3ZSBjYW4g bWFzayB3aXRoIChzaXplLTEpIHRvIGxvb3AgYXJvdW5kKS4KKyAqLworI2RlZmluZSBfX0NPTlNU X1JJTkdfU0laRShfcywgX3N6KSBcCisgICAgKF9fUkQzMigoKF9zeikgLSBvZmZzZXRvZihzdHJ1 Y3QgX3MjI19zcmluZywgcmluZykpIC8gXAorCSAgICBzaXplb2YoKChzdHJ1Y3QgX3MjI19zcmlu ZyAqKTApLT5yaW5nWzBdKSkpCisvKgorICogVGhlIHNhbWUgZm9yIHBhc3NpbmcgaW4gYW4gYWN0 dWFsIHBvaW50ZXIgaW5zdGVhZCBvZiBhIG5hbWUgdGFnLgorICovCisjZGVmaW5lIF9fUklOR19T SVpFKF9zLCBfc3opIFwKKyAgICAoX19SRDMyKCgoX3N6KSAtIChsb25nKShfcyktPnJpbmcgKyAo bG9uZykoX3MpKSAvIHNpemVvZigoX3MpLT5yaW5nWzBdKSkpCisKKy8qCisgKiBNYWNyb3MgdG8g bWFrZSB0aGUgY29ycmVjdCBDIGRhdGF0eXBlcyBmb3IgYSBuZXcga2luZCBvZiByaW5nLgorICog CisgKiBUbyBtYWtlIGEgbmV3IHJpbmcgZGF0YXR5cGUsIHlvdSBuZWVkIHRvIGhhdmUgdHdvIG1l c3NhZ2Ugc3RydWN0dXJlcywKKyAqIGxldCdzIHNheSByZXF1ZXN0X3QsIGFuZCByZXNwb25zZV90 IGFscmVhZHkgZGVmaW5lZC4KKyAqCisgKiBJbiBhIGhlYWRlciB3aGVyZSB5b3Ugd2FudCB0aGUg cmluZyBkYXRhdHlwZSBkZWNsYXJlZCwgeW91IHRoZW4gZG86CisgKgorICogICAgIERFRklORV9S SU5HX1RZUEVTKG15dGFnLCByZXF1ZXN0X3QsIHJlc3BvbnNlX3QpOworICoKKyAqIFRoZXNlIGV4 cGFuZCBvdXQgdG8gZ2l2ZSB5b3UgYSBzZXQgb2YgdHlwZXMsIGFzIHlvdSBjYW4gc2VlIGJlbG93 LgorICogVGhlIG1vc3QgaW1wb3J0YW50IG9mIHRoZXNlIGFyZToKKyAqIAorICogICAgIG15dGFn X3NyaW5nX3QgICAgICAtIFRoZSBzaGFyZWQgcmluZy4KKyAqICAgICBteXRhZ19mcm9udF9yaW5n X3QgLSBUaGUgJ2Zyb250JyBoYWxmIG9mIHRoZSByaW5nLgorICogICAgIG15dGFnX2JhY2tfcmlu Z190ICAtIFRoZSAnYmFjaycgaGFsZiBvZiB0aGUgcmluZy4KKyAqCisgKiBUbyBpbml0aWFsaXpl IGEgcmluZyBpbiB5b3VyIGNvZGUgeW91IG5lZWQgdG8ga25vdyB0aGUgbG9jYXRpb24gYW5kIHNp emUKKyAqIG9mIHRoZSBzaGFyZWQgbWVtb3J5IGFyZWEgKFBBR0VfU0laRSwgZm9yIGluc3RhbmNl KS4gVG8gaW5pdGlhbGlzZQorICogdGhlIGZyb250IGhhbGY6CisgKgorICogICAgIG15dGFnX2Zy b250X3JpbmdfdCBmcm9udF9yaW5nOworICogICAgIFNIQVJFRF9SSU5HX0lOSVQoKG15dGFnX3Ny aW5nX3QgKilzaGFyZWRfcGFnZSk7CisgKiAgICAgRlJPTlRfUklOR19JTklUKCZmcm9udF9yaW5n LCAobXl0YWdfc3JpbmdfdCAqKXNoYXJlZF9wYWdlLCBQQUdFX1NJWkUpOworICoKKyAqIEluaXRp YWxpemluZyB0aGUgYmFjayBmb2xsb3dzIHNpbWlsYXJseSAobm90ZSB0aGF0IG9ubHkgdGhlIGZy b250CisgKiBpbml0aWFsaXplcyB0aGUgc2hhcmVkIHJpbmcpOgorICoKKyAqICAgICBteXRhZ19i YWNrX3JpbmdfdCBiYWNrX3Jpbmc7CisgKiAgICAgQkFDS19SSU5HX0lOSVQoJmJhY2tfcmluZywg KG15dGFnX3NyaW5nX3QgKilzaGFyZWRfcGFnZSwgUEFHRV9TSVpFKTsKKyAqLworCisjZGVmaW5l IERFRklORV9SSU5HX1RZUEVTKF9fbmFtZSwgX19yZXFfdCwgX19yc3BfdCkgICAgICAgICAgICAg ICAgICAgICBcCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBcCisvKiBTaGFyZWQgcmluZyBlbnRyeSAqLyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCit1bmlvbiBfX25h bWUjI19zcmluZ19lbnRyeSB7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBcCisgICAgX19yZXFfdCByZXE7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgX19yc3BfdCByc3A7ICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCit9OyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBcCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBcCisvKiBTaGFyZWQgcmluZyBwYWdlICovICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCitzdHJ1Y3QgX19uYW1lIyNf c3JpbmcgeyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBc CisgICAgUklOR19JRFggcmVxX3Byb2QsIHJlcV9ldmVudDsgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBcCisgICAgUklOR19JRFggcnNwX3Byb2QsIHJzcF9ldmVudDsgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgdW5pb24geyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisg ICAgICAgIHN0cnVjdCB7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBcCisgICAgICAgICAgICB1aW50OF90IHNtYXJ0cG9sbF9hY3RpdmU7ICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAgIH0gbmV0aWY7ICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAg ICAgIHN0cnVjdCB7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBcCisgICAgICAgICAgICB1aW50OF90IG1zZzsgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAgIH0gdGFwaWZfdXNlcjsgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAg IHVpbnQ4X3QgcHZ0X3BhZFs0XTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBcCisgICAgfSBwdnQ7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgdWludDhfdCBfX3BhZFs0NF07ICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgdW5pb24g X19uYW1lIyNfc3JpbmdfZW50cnkgcmluZ1sxXTsgLyogdmFyaWFibGUtbGVuZ3RoICovICAgICAg ICAgICBcCit9OyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisvKiAiRnJvbnQiIGVu ZCdzIHByaXZhdGUgdmFyaWFibGVzICovICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBcCitzdHJ1Y3QgX19uYW1lIyNfZnJvbnRfcmluZyB7ICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBcCisgICAgUklOR19JRFggcmVxX3Byb2RfcHZ0OyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgUklOR19JRFggcnNw X2NvbnM7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBc CisgICAgdW5zaWduZWQgaW50IG5yX2VudHM7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBcCisgICAgc3RydWN0IF9fbmFtZSMjX3NyaW5nICpzcmluZzsgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCit9OyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBcCisvKiAiQmFjayIgZW5kJ3MgcHJpdmF0ZSB2YXJpYWJsZXMgKi8gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCitzdHJ1Y3QgX19uYW1lIyNfYmFja19y aW5nIHsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAg UklOR19JRFggcnNwX3Byb2RfcHZ0OyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBcCisgICAgUklOR19JRFggcmVxX2NvbnM7ICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgdW5zaWduZWQgaW50IG5yX2VudHM7 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgc3Ry dWN0IF9fbmFtZSMjX3NyaW5nICpzcmluZzsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBcCit9OyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisvKiBTeW50YWN0 aWMgc3VnYXIgKi8gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBcCit0eXBlZGVmIHN0cnVjdCBfX25hbWUjI19zcmluZyBfX25hbWUjI19zcmluZ190OyAg ICAgICAgICAgICAgICAgICAgICAgICBcCit0eXBlZGVmIHN0cnVjdCBfX25hbWUjI19mcm9udF9y aW5nIF9fbmFtZSMjX2Zyb250X3JpbmdfdDsgICAgICAgICAgICAgICBcCit0eXBlZGVmIHN0cnVj dCBfX25hbWUjI19iYWNrX3JpbmcgX19uYW1lIyNfYmFja19yaW5nX3QKKworLyoKKyAqIE1hY3Jv cyBmb3IgbWFuaXB1bGF0aW5nIHJpbmdzLgorICogCisgKiBGUk9OVF9SSU5HX3doYXRldmVyIHdv cmtzIG9uIHRoZSAiZnJvbnQgZW5kIiBvZiBhIHJpbmc6IGhlcmUgCisgKiByZXF1ZXN0cyBhcmUg cHVzaGVkIG9uIHRvIHRoZSByaW5nIGFuZCByZXNwb25zZXMgdGFrZW4gb2ZmIGl0LgorICogCisg KiBCQUNLX1JJTkdfd2hhdGV2ZXIgd29ya3Mgb24gdGhlICJiYWNrIGVuZCIgb2YgYSByaW5nOiBo ZXJlIAorICogcmVxdWVzdHMgYXJlIHRha2VuIG9mZiB0aGUgcmluZyBhbmQgcmVzcG9uc2VzIHB1 dCBvbi4KKyAqIAorICogTi5CLiB0aGVzZSBtYWNyb3MgZG8gTk8gSU5URVJMT0NLUyBPUiBGTE9X IENPTlRST0wuIAorICogVGhpcyBpcyBPSyBpbiAxLWZvci0xIHJlcXVlc3QtcmVzcG9uc2Ugc2l0 dWF0aW9ucyB3aGVyZSB0aGUgCisgKiByZXF1ZXN0b3IgKGZyb250IGVuZCkgbmV2ZXIgaGFzIG1v cmUgdGhhbiBSSU5HX1NJWkUoKS0xCisgKiBvdXRzdGFuZGluZyByZXF1ZXN0cy4KKyAqLworCisv KiBJbml0aWFsaXNpbmcgZW1wdHkgcmluZ3MgKi8KKyNkZWZpbmUgU0hBUkVEX1JJTkdfSU5JVChf cykgZG8geyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAoX3Mp LT5yZXFfcHJvZCAgPSAoX3MpLT5yc3BfcHJvZCAgPSAwOyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIFwKKyAgICAoX3MpLT5yZXFfZXZlbnQgPSAoX3MpLT5yc3BfZXZlbnQgPSAxOyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAodm9pZCltZW1zZXQoKF9zKS0+cHZ0LnB2 dF9wYWQsIDAsIHNpemVvZigoX3MpLT5wdnQucHZ0X3BhZCkpOyAgICAgIFwKKyAgICAodm9pZClt ZW1zZXQoKF9zKS0+X19wYWQsIDAsIHNpemVvZigoX3MpLT5fX3BhZCkpOyAgICAgICAgICAgICAg ICAgIFwKK30gd2hpbGUoMCkKKworI2RlZmluZSBGUk9OVF9SSU5HX0lOSVQoX3IsIF9zLCBfX3Np emUpIGRvIHsgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgIChfciktPnJlcV9wcm9k X3B2dCA9IDA7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAor ICAgIChfciktPnJzcF9jb25zID0gMDsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgXAorICAgIChfciktPm5yX2VudHMgPSBfX1JJTkdfU0laRShfcywgX19z aXplKTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgIChfciktPnNyaW5nID0gKF9z KTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorfSB3 aGlsZSAoMCkKKworI2RlZmluZSBCQUNLX1JJTkdfSU5JVChfciwgX3MsIF9fc2l6ZSkgZG8geyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgIChfciktPnJzcF9wcm9kX3B2dCA9IDA7 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgIChfcikt PnJlcV9jb25zID0gMDsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgXAorICAgIChfciktPm5yX2VudHMgPSBfX1JJTkdfU0laRShfcywgX19zaXplKTsgICAg ICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgIChfciktPnNyaW5nID0gKF9zKTsgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorfSB3aGlsZSAoMCkK KworLyogSG93IGJpZyBpcyB0aGlzIHJpbmc/ICovCisjZGVmaW5lIFJJTkdfU0laRShfcikgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgKChf ciktPm5yX2VudHMpCisKKy8qIE51bWJlciBvZiBmcmVlIHJlcXVlc3RzIChmb3IgdXNlIG9uIGZy b250IHNpZGUgb25seSkuICovCisjZGVmaW5lIFJJTkdfRlJFRV9SRVFVRVNUUyhfcikgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgKFJJTkdfU0laRShfcikg LSAoKF9yKS0+cmVxX3Byb2RfcHZ0IC0gKF9yKS0+cnNwX2NvbnMpKQorCisvKiBUZXN0IGlmIHRo ZXJlIGlzIGFuIGVtcHR5IHNsb3QgYXZhaWxhYmxlIG9uIHRoZSBmcm9udCByaW5nLgorICogKFRo aXMgaXMgb25seSBtZWFuaW5nZnVsIGZyb20gdGhlIGZyb250LiApCisgKi8KKyNkZWZpbmUgUklO R19GVUxMKF9yKSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIFwKKyAgICAoUklOR19GUkVFX1JFUVVFU1RTKF9yKSA9PSAwKQorCisvKiBUZXN0IGlmIHRo ZXJlIGFyZSBvdXRzdGFuZGluZyBtZXNzYWdlcyB0byBiZSBwcm9jZXNzZWQgb24gYSByaW5nLiAq LworI2RlZmluZSBSSU5HX0hBU19VTkNPTlNVTUVEX1JFU1BPTlNFUyhfcikgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgXAorICAgICgoX3IpLT5zcmluZy0+cnNwX3Byb2QgLSAoX3IpLT5y c3BfY29ucykKKworI2lmZGVmIF9fR05VQ19fCisjZGVmaW5lIFJJTkdfSEFTX1VOQ09OU1VNRURf UkVRVUVTVFMoX3IpICh7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgdW5zaWdu ZWQgaW50IHJlcSA9IChfciktPnNyaW5nLT5yZXFfcHJvZCAtIChfciktPnJlcV9jb25zOyAgICAg ICAgICBcCisgICAgdW5zaWduZWQgaW50IHJzcCA9IFJJTkdfU0laRShfcikgLSAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAgICgoX3IpLT5yZXFfY29ucyAtIChfcikt PnJzcF9wcm9kX3B2dCk7ICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgcmVxIDwgcnNw ID8gcmVxIDogcnNwOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBcCit9KQorI2Vsc2UKKy8qIFNhbWUgYXMgYWJvdmUsIGJ1dCB3aXRob3V0IHRoZSBuaWNlIEdD QyAoeyAuLi4gfSkgc3ludGF4LiAqLworI2RlZmluZSBSSU5HX0hBU19VTkNPTlNVTUVEX1JFUVVF U1RTKF9yKSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgICgoKChfciktPnNy aW5nLT5yZXFfcHJvZCAtIChfciktPnJlcV9jb25zKSA8ICAgICAgICAgICAgICAgICAgICAgICAg XAorICAgICAgKFJJTkdfU0laRShfcikgLSAoKF9yKS0+cmVxX2NvbnMgLSAoX3IpLT5yc3BfcHJv ZF9wdnQpKSkgPyAgICAgICAgXAorICAgICAoKF9yKS0+c3JpbmctPnJlcV9wcm9kIC0gKF9yKS0+ cmVxX2NvbnMpIDogICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgICAoUklOR19TSVpFKF9y KSAtICgoX3IpLT5yZXFfY29ucyAtIChfciktPnJzcF9wcm9kX3B2dCkpKQorI2VuZGlmCisKKy8q IERpcmVjdCBhY2Nlc3MgdG8gaW5kaXZpZHVhbCByaW5nIGVsZW1lbnRzLCBieSBpbmRleC4gKi8K KyNkZWZpbmUgUklOR19HRVRfUkVRVUVTVChfciwgX2lkeCkgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFwKKyAgICAoJigoX3IpLT5zcmluZy0+cmluZ1soKF9pZHgpICYgKFJJ TkdfU0laRShfcikgLSAxKSldLnJlcSkpCisKKy8qCisgKiBHZXQgYSBsb2NhbCBjb3B5IG9mIGEg cmVxdWVzdC4KKyAqCisgKiBVc2UgdGhpcyBpbiBwcmVmZXJlbmNlIHRvIFJJTkdfR0VUX1JFUVVF U1QoKSBzbyBhbGwgcHJvY2Vzc2luZyBpcworICogZG9uZSBvbiBhIGxvY2FsIGNvcHkgdGhhdCBj YW5ub3QgYmUgbW9kaWZpZWQgYnkgdGhlIG90aGVyIGVuZC4KKyAqCisgKiBOb3RlIHRoYXQgaHR0 cHM6Ly9nY2MuZ251Lm9yZy9idWd6aWxsYS9zaG93X2J1Zy5jZ2k/aWQ9NTgxNDUgbWF5IGNhdXNl IHRoaXMKKyAqIHRvIGJlIGluZWZmZWN0aXZlIHdoZXJlIF9yZXEgaXMgYSBzdHJ1Y3Qgd2hpY2gg Y29uc2lzdHMgb2Ygb25seSBiaXRmaWVsZHMuCisgKi8KKyNkZWZpbmUgUklOR19DT1BZX1JFUVVF U1QoX3IsIF9pZHgsIF9yZXEpIGRvIHsJCQkJXAorCS8qIFVzZSB2b2xhdGlsZSB0byBmb3JjZSB0 aGUgY29weSBpbnRvIF9yZXEuICovCQkJXAorCSooX3JlcSkgPSAqKHZvbGF0aWxlIHR5cGVvZihf cmVxKSlSSU5HX0dFVF9SRVFVRVNUKF9yLCBfaWR4KTsJXAorfSB3aGlsZSAoMCkKKworI2RlZmlu ZSBSSU5HX0dFVF9SRVNQT05TRShfciwgX2lkeCkgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgXAorICAgICgmKChfciktPnNyaW5nLT5yaW5nWygoX2lkeCkgJiAoUklOR19TSVpF KF9yKSAtIDEpKV0ucnNwKSkKKworLyogTG9vcCB0ZXJtaW5hdGlvbiBjb25kaXRpb246IFdvdWxk IHRoZSBzcGVjaWZpZWQgaW5kZXggb3ZlcmZsb3cgdGhlIHJpbmc/ICovCisjZGVmaW5lIFJJTkdf UkVRVUVTVF9DT05TX09WRVJGTE9XKF9yLCBfY29ucykgICAgICAgICAgICAgICAgICAgICAgICAg ICBcCisgICAgKCgoX2NvbnMpIC0gKF9yKS0+cnNwX3Byb2RfcHZ0KSA+PSBSSU5HX1NJWkUoX3Ip KQorCisvKiBJbGwtYmVoYXZlZCBmcm9udGVuZCBkZXRlcm1pbmF0aW9uOiBDYW4gdGhlcmUgYmUg dGhpcyBtYW55IHJlcXVlc3RzPyAqLworI2RlZmluZSBSSU5HX1JFUVVFU1RfUFJPRF9PVkVSRkxP VyhfciwgX3Byb2QpICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgICgoKF9wcm9kKSAt IChfciktPnJzcF9wcm9kX3B2dCkgPiBSSU5HX1NJWkUoX3IpKQorCisjZGVmaW5lIFJJTkdfUFVT SF9SRVFVRVNUUyhfcikgZG8geyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBc CisgICAgeGVuX3dtYigpOyAvKiBiYWNrIHNlZXMgcmVxdWVzdHMgL2JlZm9yZS8gdXBkYXRlZCBw cm9kdWNlciBpbmRleCAqLyBcCisgICAgKF9yKS0+c3JpbmctPnJlcV9wcm9kID0gKF9yKS0+cmVx X3Byb2RfcHZ0OyAgICAgICAgICAgICAgICAgICAgICAgICBcCit9IHdoaWxlICgwKQorCisjZGVm aW5lIFJJTkdfUFVTSF9SRVNQT05TRVMoX3IpIGRvIHsgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBcCisgICAgeGVuX3dtYigpOyAvKiBmcm9udCBzZWVzIHJlc3BzIC9iZWZvcmUv IHVwZGF0ZWQgcHJvZHVjZXIgaW5kZXggKi8gICBcCisgICAgKF9yKS0+c3JpbmctPnJzcF9wcm9k ID0gKF9yKS0+cnNwX3Byb2RfcHZ0OyAgICAgICAgICAgICAgICAgICAgICAgICBcCit9IHdoaWxl ICgwKQorCisvKgorICogTm90aWZpY2F0aW9uIGhvbGQtb2ZmIChyZXFfZXZlbnQgYW5kIHJzcF9l dmVudCk6CisgKiAKKyAqIFdoZW4gcXVldWVpbmcgcmVxdWVzdHMgb3IgcmVzcG9uc2VzIG9uIGEg c2hhcmVkIHJpbmcsIGl0IG1heSBub3QgYWx3YXlzIGJlCisgKiBuZWNlc3NhcnkgdG8gbm90aWZ5 IHRoZSByZW1vdGUgZW5kLiBGb3IgZXhhbXBsZSwgaWYgcmVxdWVzdHMgYXJlIGluIGZsaWdodAor ICogaW4gYSBiYWNrZW5kLCB0aGUgZnJvbnQgbWF5IGJlIGFibGUgdG8gcXVldWUgZnVydGhlciBy ZXF1ZXN0cyB3aXRob3V0CisgKiBub3RpZnlpbmcgdGhlIGJhY2sgKGlmIHRoZSBiYWNrIGNoZWNr cyBmb3IgbmV3IHJlcXVlc3RzIHdoZW4gaXQgcXVldWVzCisgKiByZXNwb25zZXMpLgorICogCisg KiBXaGVuIGVucXVldWluZyByZXF1ZXN0cyBvciByZXNwb25zZXM6CisgKiAKKyAqICBVc2UgUklO R19QVVNIX3tSRVFVRVNUUyxSRVNQT05TRVN9X0FORF9DSEVDS19OT1RJRlkoKS4gVGhlIHNlY29u ZCBhcmd1bWVudAorICogIGlzIGEgYm9vbGVhbiByZXR1cm4gdmFsdWUuIFRydWUgaW5kaWNhdGVz IHRoYXQgdGhlIHJlY2VpdmVyIHJlcXVpcmVzIGFuCisgKiAgYXN5bmNocm9ub3VzIG5vdGlmaWNh dGlvbi4KKyAqIAorICogQWZ0ZXIgZGVxdWV1aW5nIHJlcXVlc3RzIG9yIHJlc3BvbnNlcyAoYmVm b3JlIHNsZWVwaW5nIHRoZSBjb25uZWN0aW9uKToKKyAqIAorICogIFVzZSBSSU5HX0ZJTkFMX0NI RUNLX0ZPUl9SRVFVRVNUUygpIG9yIFJJTkdfRklOQUxfQ0hFQ0tfRk9SX1JFU1BPTlNFUygpLgor ICogIFRoZSBzZWNvbmQgYXJndW1lbnQgaXMgYSBib29sZWFuIHJldHVybiB2YWx1ZS4gVHJ1ZSBp bmRpY2F0ZXMgdGhhdCB0aGVyZQorICogIGFyZSBwZW5kaW5nIG1lc3NhZ2VzIG9uIHRoZSByaW5n IChpLmUuLCB0aGUgY29ubmVjdGlvbiBzaG91bGQgbm90IGJlIHB1dAorICogIHRvIHNsZWVwKS4K KyAqIAorICogIFRoZXNlIG1hY3JvcyB3aWxsIHNldCB0aGUgcmVxX2V2ZW50L3JzcF9ldmVudCBm aWVsZCB0byB0cmlnZ2VyIGEKKyAqICBub3RpZmljYXRpb24gb24gdGhlIHZlcnkgbmV4dCBtZXNz YWdlIHRoYXQgaXMgZW5xdWV1ZWQuIElmIHlvdSB3YW50IHRvCisgKiAgY3JlYXRlIGJhdGNoZXMg b2Ygd29yayAoaS5lLiwgb25seSByZWNlaXZlIGEgbm90aWZpY2F0aW9uIGFmdGVyIHNldmVyYWwK KyAqICBtZXNzYWdlcyBoYXZlIGJlZW4gZW5xdWV1ZWQpIHRoZW4geW91IHdpbGwgbmVlZCB0byBj cmVhdGUgYSBjdXN0b21pc2VkCisgKiAgdmVyc2lvbiBvZiB0aGUgRklOQUxfQ0hFQ0sgbWFjcm8g aW4geW91ciBvd24gY29kZSwgd2hpY2ggc2V0cyB0aGUgZXZlbnQKKyAqICBmaWVsZCBhcHByb3By aWF0ZWx5LgorICovCisKKyNkZWZpbmUgUklOR19QVVNIX1JFUVVFU1RTX0FORF9DSEVDS19OT1RJ RlkoX3IsIF9ub3RpZnkpIGRvIHsgICAgICAgICAgIFwKKyAgICBSSU5HX0lEWCBfX29sZCA9IChf ciktPnNyaW5nLT5yZXFfcHJvZDsgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICBS SU5HX0lEWCBfX25ldyA9IChfciktPnJlcV9wcm9kX3B2dDsgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIFwKKyAgICB4ZW5fd21iKCk7IC8qIGJhY2sgc2VlcyByZXF1ZXN0cyAvYmVmb3Jl LyB1cGRhdGVkIHByb2R1Y2VyIGluZGV4ICovIFwKKyAgICAoX3IpLT5zcmluZy0+cmVxX3Byb2Qg PSBfX25ldzsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICB4ZW5f bWIoKTsgLyogYmFjayBzZWVzIG5ldyByZXF1ZXN0cyAvYmVmb3JlLyB3ZSBjaGVjayByZXFfZXZl bnQgKi8gIFwKKyAgICAoX25vdGlmeSkgPSAoKFJJTkdfSURYKShfX25ldyAtIChfciktPnNyaW5n LT5yZXFfZXZlbnQpIDwgICAgICAgICAgIFwKKyAgICAgICAgICAgICAgICAgKFJJTkdfSURYKShf X25ldyAtIF9fb2xkKSk7ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKK30gd2hpbGUgKDAp CisKKyNkZWZpbmUgUklOR19QVVNIX1JFU1BPTlNFU19BTkRfQ0hFQ0tfTk9USUZZKF9yLCBfbm90 aWZ5KSBkbyB7ICAgICAgICAgIFwKKyAgICBSSU5HX0lEWCBfX29sZCA9IChfciktPnNyaW5nLT5y c3BfcHJvZDsgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICBSSU5HX0lEWCBfX25l dyA9IChfciktPnJzcF9wcm9kX3B2dDsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwK KyAgICB4ZW5fd21iKCk7IC8qIGZyb250IHNlZXMgcmVzcHMgL2JlZm9yZS8gdXBkYXRlZCBwcm9k dWNlciBpbmRleCAqLyAgIFwKKyAgICAoX3IpLT5zcmluZy0+cnNwX3Byb2QgPSBfX25ldzsgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICB4ZW5fbWIoKTsgLyogZnJv bnQgc2VlcyBuZXcgcmVzcHMgL2JlZm9yZS8gd2UgY2hlY2sgcnNwX2V2ZW50ICovICAgIFwKKyAg ICAoX25vdGlmeSkgPSAoKFJJTkdfSURYKShfX25ldyAtIChfciktPnNyaW5nLT5yc3BfZXZlbnQp IDwgICAgICAgICAgIFwKKyAgICAgICAgICAgICAgICAgKFJJTkdfSURYKShfX25ldyAtIF9fb2xk KSk7ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKK30gd2hpbGUgKDApCisKKyNkZWZpbmUg UklOR19GSU5BTF9DSEVDS19GT1JfUkVRVUVTVFMoX3IsIF93b3JrX3RvX2RvKSBkbyB7ICAgICAg ICAgICAgIFwKKyAgICAoX3dvcmtfdG9fZG8pID0gUklOR19IQVNfVU5DT05TVU1FRF9SRVFVRVNU Uyhfcik7ICAgICAgICAgICAgICAgICAgIFwKKyAgICBpZiAoX3dvcmtfdG9fZG8pIGJyZWFrOyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAoX3IpLT5z cmluZy0+cmVxX2V2ZW50ID0gKF9yKS0+cmVxX2NvbnMgKyAxOyAgICAgICAgICAgICAgICAgICAg ICAgIFwKKyAgICB4ZW5fbWIoKTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAoX3dvcmtfdG9fZG8pID0gUklOR19IQVNfVU5D T05TVU1FRF9SRVFVRVNUUyhfcik7ICAgICAgICAgICAgICAgICAgIFwKK30gd2hpbGUgKDApCisK KyNkZWZpbmUgUklOR19GSU5BTF9DSEVDS19GT1JfUkVTUE9OU0VTKF9yLCBfd29ya190b19kbykg ZG8geyAgICAgICAgICAgIFwKKyAgICAoX3dvcmtfdG9fZG8pID0gUklOR19IQVNfVU5DT05TVU1F RF9SRVNQT05TRVMoX3IpOyAgICAgICAgICAgICAgICAgIFwKKyAgICBpZiAoX3dvcmtfdG9fZG8p IGJyZWFrOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAg ICAoX3IpLT5zcmluZy0+cnNwX2V2ZW50ID0gKF9yKS0+cnNwX2NvbnMgKyAxOyAgICAgICAgICAg ICAgICAgICAgICAgIFwKKyAgICB4ZW5fbWIoKTsgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAoX3dvcmtfdG9fZG8pID0gUklO R19IQVNfVU5DT05TVU1FRF9SRVNQT05TRVMoX3IpOyAgICAgICAgICAgICAgICAgIFwKK30gd2hp bGUgKDApCisKKworLyoKKyAqIERFRklORV9YRU5fRkxFWF9SSU5HX0FORF9JTlRGIGRlZmluZXMg dHdvIG1vbm9kaXJlY3Rpb25hbCByaW5ncyBhbmQKKyAqIGZ1bmN0aW9ucyB0byBjaGVjayBpZiB0 aGVyZSBpcyBkYXRhIG9uIHRoZSByaW5nLCBhbmQgdG8gcmVhZCBhbmQKKyAqIHdyaXRlIHRvIHRo ZW0uCisgKgorICogREVGSU5FX1hFTl9GTEVYX1JJTkcgaXMgc2ltaWxhciB0byBERUZJTkVfWEVO X0ZMRVhfUklOR19BTkRfSU5URiwgYnV0CisgKiBkb2VzIG5vdCBkZWZpbmUgdGhlIGluZGV4ZXMg cGFnZS4gQXMgZGlmZmVyZW50IHByb3RvY29scyBjYW4gaGF2ZQorICogZXh0ZW5zaW9ucyB0byB0 aGUgYmFzaWMgZm9ybWF0LCB0aGlzIG1hY3JvIGFsbG93IHRoZW0gdG8gZGVmaW5lIHRoZWlyCisg KiBvd24gc3RydWN0LgorICoKKyAqIFhFTl9GTEVYX1JJTkdfU0laRQorICogICBDb252ZW5pZW5j ZSBtYWNybyB0byBjYWxjdWxhdGUgdGhlIHNpemUgb2Ygb25lIG9mIHRoZSB0d28gcmluZ3MKKyAq ICAgZnJvbSB0aGUgb3ZlcmFsbCBvcmRlci4KKyAqCisgKiAkTkFNRV9tYXNrCisgKiAgIEZ1bmN0 aW9uIHRvIGFwcGx5IHRoZSBzaXplIG1hc2sgdG8gYW4gaW5kZXgsIHRvIHJlZHVjZSB0aGUgaW5k ZXgKKyAqICAgd2l0aGluIHRoZSByYW5nZSBbMC1zaXplXS4KKyAqCisgKiAkTkFNRV9yZWFkX3Bh Y2tldAorICogICBGdW5jdGlvbiB0byByZWFkIGRhdGEgZnJvbSB0aGUgcmluZy4gVGhlIGFtb3Vu dCBvZiBkYXRhIHRvIHJlYWQgaXMKKyAqICAgc3BlY2lmaWVkIGJ5IHRoZSAic2l6ZSIgYXJndW1l bnQuCisgKgorICogJE5BTUVfd3JpdGVfcGFja2V0CisgKiAgIEZ1bmN0aW9uIHRvIHdyaXRlIGRh dGEgdG8gdGhlIHJpbmcuIFRoZSBhbW91bnQgb2YgZGF0YSB0byB3cml0ZSBpcworICogICBzcGVj aWZpZWQgYnkgdGhlICJzaXplIiBhcmd1bWVudC4KKyAqCisgKiAkTkFNRV9nZXRfcmluZ19wdHIK KyAqICAgQ29udmVuaWVuY2UgZnVuY3Rpb24gdGhhdCByZXR1cm5zIGEgcG9pbnRlciB0byByZWFk L3dyaXRlIHRvIHRoZQorICogICByaW5nIGF0IHRoZSByaWdodCBsb2NhdGlvbi4KKyAqCisgKiAk TkFNRV9kYXRhX2ludGYKKyAqICAgSW5kZXhlcyBwYWdlLCBzaGFyZWQgYmV0d2VlbiBmcm9udGVu ZCBhbmQgYmFja2VuZC4gSXQgYWxzbworICogICBjb250YWlucyB0aGUgYXJyYXkgb2YgZ3JhbnQg cmVmcy4KKyAqCisgKiAkTkFNRV9xdWV1ZWQKKyAqICAgRnVuY3Rpb24gdG8gY2FsY3VsYXRlIGhv dyBtYW55IGJ5dGVzIGFyZSBjdXJyZW50bHkgb24gdGhlIHJpbmcsCisgKiAgIHJlYWR5IHRvIGJl IHJlYWQuIEl0IGNhbiBhbHNvIGJlIHVzZWQgdG8gY2FsY3VsYXRlIGhvdyBtdWNoIGZyZWUKKyAq ICAgc3BhY2UgaXMgY3VycmVudGx5IG9uIHRoZSByaW5nIChyaW5nX3NpemUgLSAkTkFNRV9xdWV1 ZWQoKSkuCisgKi8KKyNkZWZpbmUgWEVOX0ZMRVhfUklOR19TSVpFKG9yZGVyKSAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAoMVVMIDw8IChvcmRlciAr IFBBR0VfU0hJRlQgLSAxKSkKKworI2RlZmluZSBERUZJTkVfWEVOX0ZMRVhfUklOR19BTkRfSU5U RihuYW1lKSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorc3RydWN0IG5hbWUj I19kYXRhX2ludGYgeyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgXAorICAgIFJJTkdfSURYIGluX2NvbnMsIGluX3Byb2Q7ICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg XAorICAgIHVpbnQ4X3QgcGFkMVs1Nl07ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgIFJJ TkdfSURYIG91dF9jb25zLCBvdXRfcHJvZDsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgXAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgIHVpbnQ4X3QgcGFk Mls1Nl07ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgXAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgIFJJTkdfSURYIHJpbmdfb3JkZXI7 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAor ICAgIGdyYW50X3JlZl90IHJlZltdOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgXAorfTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorREVGSU5FX1hF Tl9GTEVYX1JJTkcobmFtZSk7CisKKyNkZWZpbmUgREVGSU5FX1hFTl9GTEVYX1JJTkcobmFtZSkg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKK3N0YXRpYyBpbmxp bmUgUklOR19JRFggbmFtZSMjX21hc2soUklOR19JRFggaWR4LCBSSU5HX0lEWCByaW5nX3NpemUp ICAgICAgICAgIFwKK3sgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICByZXR1cm4gKGlkeCAmIChy aW5nX3NpemUgLSAxKSk7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IFwKK30gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKK3N0YXRp YyBpbmxpbmUgUklOR19JRFggbmFtZSMjX21hc2tfb3JkZXIoUklOR19JRFggaWR4LCBSSU5HX0lE WCByaW5nX29yZGVyKSAgIFwKK3sgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICByZXR1cm4gKGlk eCAmIChYRU5fRkxFWF9SSU5HX1NJWkUocmluZ19vcmRlcikgLSAxKSk7ICAgICAgICAgICAgICAg ICAgICAgIFwKK30gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwK K3N0YXRpYyBpbmxpbmUgdW5zaWduZWQgY2hhciogbmFtZSMjX2dldF9yaW5nX3B0cih1bnNpZ25l ZCBjaGFyICpidWYsICAgICAgICAgIFwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBSSU5HX0lEWCBpZHgsICAgICAgICAgICAgICAgIFwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBSSU5HX0lEWCByaW5nX29y ZGVyKSAgICAgICAgIFwKK3sgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICByZXR1cm4gYnVmICsg bmFtZSMjX21hc2tfb3JkZXIoaWR4LCByaW5nX29yZGVyKTsgICAgICAgICAgICAgICAgICAgICAg ICAgIFwKK30gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKK3N0 YXRpYyBpbmxpbmUgdm9pZCBuYW1lIyNfcmVhZF9wYWNrZXQoY29uc3QgdW5zaWduZWQgY2hhciAq YnVmLCAgICAgICAgICAgICAgIFwKKyAgICAgICAgUklOR19JRFggbWFza2VkX3Byb2QsIFJJTkdf SURYICptYXNrZWRfY29ucywgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgUklO R19JRFggcmluZ19zaXplLCB2b2lkICpvcGFxdWUsIHNpemVfdCBzaXplKSB7ICAgICAgICAgICAg ICAgICAgICAgIFwKKyAgICBpZiAoKm1hc2tlZF9jb25zIDwgbWFza2VkX3Byb2QgfHwgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgICAgIHNpemUgPD0g cmluZ19zaXplIC0gKm1hc2tlZF9jb25zKSB7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IFwKKyAgICAgICAgbWVtY3B5KG9wYXF1ZSwgYnVmICsgKm1hc2tlZF9jb25zLCBzaXplKTsgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICB9IGVsc2UgeyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAg ICAgbWVtY3B5KG9wYXF1ZSwgYnVmICsgKm1hc2tlZF9jb25zLCByaW5nX3NpemUgLSAqbWFza2Vk X2NvbnMpOyAgICAgICAgIFwKKyAgICAgICAgbWVtY3B5KCh1bnNpZ25lZCBjaGFyICopb3BhcXVl ICsgcmluZ19zaXplIC0gKm1hc2tlZF9jb25zLCBidWYsICAgICAgIFwKKyAgICAgICAgICAgICAg ICBzaXplIC0gKHJpbmdfc2l6ZSAtICptYXNrZWRfY29ucykpOyAgICAgICAgICAgICAgICAgICAg ICAgICAgIFwKKyAgICB9ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAqbWFza2VkX2NvbnMgPSBuYW1l IyNfbWFzaygqbWFza2VkX2NvbnMgKyBzaXplLCByaW5nX3NpemUpOyAgICAgICAgICAgICAgIFwK K30gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKK3N0YXRpYyBp bmxpbmUgdm9pZCBuYW1lIyNfd3JpdGVfcGFja2V0KHVuc2lnbmVkIGNoYXIgKmJ1ZiwgICAgICAg ICAgICAgICAgICAgIFwKKyAgICAgICAgUklOR19JRFggKm1hc2tlZF9wcm9kLCBSSU5HX0lEWCBt YXNrZWRfY29ucywgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgUklOR19JRFgg cmluZ19zaXplLCBjb25zdCB2b2lkICpvcGFxdWUsIHNpemVfdCBzaXplKSB7ICAgICAgICAgICAg ICAgIFwKKyAgICBpZiAoKm1hc2tlZF9wcm9kIDwgbWFza2VkX2NvbnMgfHwgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgc2l6ZSA8PSByaW5nX3NpemUg LSAqbWFza2VkX3Byb2QpIHsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAg ICAgICAgbWVtY3B5KGJ1ZiArICptYXNrZWRfcHJvZCwgb3BhcXVlLCBzaXplKTsgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIFwKKyAgICB9IGVsc2UgeyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgbWVt Y3B5KGJ1ZiArICptYXNrZWRfcHJvZCwgb3BhcXVlLCByaW5nX3NpemUgLSAqbWFza2VkX3Byb2Qp OyAgICAgICAgIFwKKyAgICAgICAgbWVtY3B5KGJ1ZiwgKHVuc2lnbmVkIGNoYXIgKilvcGFxdWUg KyAocmluZ19zaXplIC0gKm1hc2tlZF9wcm9kKSwgICAgIFwKKyAgICAgICAgICAgICAgICBzaXpl IC0gKHJpbmdfc2l6ZSAtICptYXNrZWRfcHJvZCkpOyAgICAgICAgICAgICAgICAgICAgICAgICAg IFwKKyAgICB9ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAqbWFza2VkX3Byb2QgPSBuYW1lIyNfbWFz aygqbWFza2VkX3Byb2QgKyBzaXplLCByaW5nX3NpemUpOyAgICAgICAgICAgICAgIFwKK30gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKK3N0cnVjdCBuYW1lIyNf ZGF0YSB7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIFwKKyAgICB1bnNpZ25lZCBjaGFyICppbjsgLyogaGFsZiBvZiB0aGUgYWxsb2NhdGlv biAqLyAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICB1bnNpZ25lZCBjaGFyICpvdXQ7 IC8qIGhhbGYgb2YgdGhlIGFsbG9jYXRpb24gKi8gICAgICAgICAgICAgICAgICAgICAgICAgIFwK K307ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIFwKK3N0YXRpYyBpbmxpbmUgUklOR19JRFggbmFtZSMjX3F1ZXVlZChSSU5H X0lEWCBwcm9kLCAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgUklOR19JRFgg Y29ucywgUklOR19JRFggcmluZ19zaXplKSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIFwKK3sgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICBSSU5HX0lEWCBzaXplOyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIFwKKyAgICBpZiAocHJvZCA9PSBjb25zKSAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgcmV0 dXJuIDA7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIFwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICBwcm9kID0gbmFtZSMjX21h c2socHJvZCwgcmluZ19zaXplKTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IFwKKyAgICBjb25zID0gbmFtZSMjX21hc2soY29ucywgcmluZ19zaXplKTsgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICBp ZiAocHJvZCA9PSBjb25zKSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFwKKyAgICAgICAgcmV0dXJuIHJpbmdfc2l6ZTsgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIFwKKyAgICBpZiAocHJvZCA+IGNvbnMpICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgc2l6ZSA9IHByb2QgLSBj b25zOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwK KyAgICBlbHNlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAgc2l6ZSA9IHJpbmdfc2l6ZSAtIChjb25z IC0gcHJvZCk7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICByZXR1 cm4gc2l6ZTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIFwKK307CisKKyNlbmRpZiAvKiBfX1hFTl9QVUJMSUNfSU9fUklOR19IX18g Ki8KKworLyoKKyAqIExvY2FsIHZhcmlhYmxlczoKKyAqIG1vZGU6IEMKKyAqIGMtZmlsZS1zdHls ZTogIkJTRCIKKyAqIGMtYmFzaWMtb2Zmc2V0OiA0CisgKiB0YWItd2lkdGg6IDQKKyAqIGluZGVu dC10YWJzLW1vZGU6IG5pbAorICogRW5kOgorICovCi0tIAoxLjkuMQoKCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QK WGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0cHM6Ly9saXN0cy54ZW4ub3JnL3hlbi1kZXZlbAo=