From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-oi0-x22d.google.com (mail-oi0-x22d.google.com [IPv6:2607:f8b0:4003:c06::22d]) (using TLSv1 with cipher RC4-SHA (128/128 bits)) (Client CN "smtp.gmail.com", Issuer "Google Internet Authority G2" (verified OK)) by huchra.bufferbloat.net (Postfix) with ESMTPS id 8905E21F311 for ; Fri, 20 Nov 2015 04:25:35 -0800 (PST) Received: by oige206 with SMTP id e206so63354960oig.2 for ; Fri, 20 Nov 2015 04:25:34 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=mime-version:date:message-id:subject:from:to:content-type; bh=/VdNBcd41C1qhm68DY3AxHrSP8H0O98Eklm76lReuB8=; b=sS9myinIssyzLG5oXjyU/92zMs0GaGkRNOYPN4ju2EAdih09geH74KK3SAt/ghCbCw iHigEm0UQDF/sXeHIEh24IZsLEqWfIugex39RHzPAEsLFhzwjeIVnxZtEHMWJex+cnkW nDJ42KMpAfql/42iBeVdSqIVudv5JFkI1btZy7OC7qGSkPcTg+zGAgdxIhNPZlgs4691 YnOkVd3VHXu1t6s0EkAvjAZG2boNQSZossMbt5SWWdXS2KUYgONxdEo7L+m9YASqbuyC qqsmGzifypxwDYrIwbzWZbFPM75iJQubZEEKwbRCX2QOnXSJoE31qaIhSgNsjKIIHMGk VZAg== MIME-Version: 1.0 X-Received: by 10.202.83.74 with SMTP id h71mr8147946oib.32.1448022334373; Fri, 20 Nov 2015 04:25:34 -0800 (PST) Received: by 10.202.50.130 with HTTP; Fri, 20 Nov 2015 04:25:34 -0800 (PST) Date: Fri, 20 Nov 2015 13:25:34 +0100 Message-ID: From: Dave Taht To: cake@lists.bufferbloat.net Content-Type: multipart/mixed; boundary=001a113d12a4de223b0524f7f87b Subject: [Cake] backward compatibility cruft and possible performance optimizaton X-BeenThere: cake@lists.bufferbloat.net X-Mailman-Version: 2.1.13 Precedence: list List-Id: Cake - FQ_codel the next generation List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 20 Nov 2015 12:25:57 -0000 --001a113d12a4de223b0524f7f87b Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable I just pushed a change cleaning up the typedefs. Upcoming for discussion: I was objecting to carrying around a whole lot of variables that could otherwise be kept in a ptr to their referenced codel_params structure. The ABI for most function calls in most OSes barely allows for 6 arguments before stuff gets pushed on the stack. x86 32 bit is the worst, here. On the other hand other arches have 32 or more registers, and in any case, at least on the two (x86_64, arm) arches I have built for, everything gets inlined anyway so the difference in using a codel_params p->interval, for example, vanishes, near as I can tell. (I will go disassemble) Simultaneiously (sigh), I started breaking out the compatability cruft into a separate file to make backporting as far back as 3.4 easier. Does anyone have any objection to me making these two changes (in a cleaner way than the below)? diff --git a/codel5.h b/codel5.h index d45aa6e..0c29735 100644 --- a/codel5.h +++ b/codel5.h @@ -58,66 +58,13 @@ * Implemented on linux by Dave Taht and Eric Dumazet */ -/* Backport some stuff if needed. - */ -#if KERNEL_VERSION(3, 14, 0) > LINUX_VERSION_CODE - -static inline u32 reciprocal_scale(u32 val, u32 ep_ro) -{ - return (u32)(((u64) val * ep_ro) >> 32); -} - -#endif - -#if KERNEL_VERSION(3, 15, 0) > LINUX_VERSION_CODE - -static inline void kvfree(const void *addr) -{ - if (is_vmalloc_addr(addr)) - vfree(addr); - else - kfree(addr); -} - -#endif - -#if KERNEL_VERSION(3, 17, 0) > LINUX_VERSION_CODE - -#define ktime_get_ns() ktime_to_ns(ktime_get()) - -#endif - -#if KERNEL_VERSION(3, 18, 0) > LINUX_VERSION_CODE -static inline void qdisc_qstats_backlog_dec(struct Qdisc *sch, - const struct sk_buff *skb) -{ - sch->qstats.backlog -=3D qdisc_pkt_len(skb); -} - -static inline void qdisc_qstats_backlog_inc(struct Qdisc *sch, - const struct sk_buff *skb) -{ - sch->qstats.backlog +=3D qdisc_pkt_len(skb); -} - -static inline void __qdisc_qstats_drop(struct Qdisc *sch, int count) -{ - sch->qstats.drops +=3D count; -} - -static inline void qdisc_qstats_drop(struct Qdisc *sch) -{ - sch->qstats.drops++; -} - -#define codel_stats_copy_queue(a, b, c, d) gnet_stats_copy_queue(a, c) -#define codel_watchdog_schedule_ns(a, b, c) qdisc_watchdog_schedule_ns(a, = b) +#if KERNEL_VERSION(4, 2, 0) > LINUX_VERSION_CODE +#include "codel5_compat.h" #else #define codel_stats_copy_queue(a, b, c, d) gnet_stats_copy_queue(a, b, c, = d) #define codel_watchdog_schedule_ns(a, b, c) qdisc_watchdog_schedule_ns(a, = b, c) #endif - /* CoDel5 uses a real clock, unlike codel */ typedef u64 codel_time_t; @@ -192,11 +139,13 @@ struct codel_vars { u16 drop_count; u16 ecn_mark; }; + /* sizeof_in_bits(rec_inv_sqrt) */ #define REC_INV_SQRT_BITS (8 * sizeof(u16)) /* needed shift to get a Q0.32 number from rec_inv_sqrt */ #define REC_INV_SQRT_SHIFT (32 - REC_INV_SQRT_BITS) -#define REC_INV_SQRT_CACHE (16) + +#define REC_INV_SQRT_CACHE (16) // fixme cache line fix /* Newton approximation method needs more iterations at small inputs, * so cache them. @@ -232,6 +181,7 @@ static void codel_Newton_step(struct codel_vars *vars) } } +// FIXME for peel threshold static void codel_cache_init(void) { struct codel_vars v; @@ -239,7 +189,7 @@ static void codel_cache_init(void) codel_vars_init(&v); v.rec_inv_sqrt =3D ~0U >> REC_INV_SQRT_SHIFT; codel_rec_inv_sqrt_cache[0] =3D v.rec_inv_sqrt; - + //fixme for no cache for (v.count =3D 1; v.count < REC_INV_SQRT_CACHE; v.count++) { codel_Newton_step(&v); codel_Newton_step(&v); @@ -267,9 +217,7 @@ static codel_time_t codel_control_law(codel_time_t t, static bool codel_should_drop(const struct sk_buff *skb, struct Qdisc *sch, struct codel_vars *vars, - codel_time_t interval, - codel_time_t target, - codel_time_t threshold, + const struct codel_params *p, codel_time_t now) { if (!skb) { @@ -279,7 +227,7 @@ static bool codel_should_drop(const struct sk_buff *skb= , sch->qstats.backlog -=3D qdisc_pkt_len(skb); - if (now - codel_get_enqueue_time(skb) < target || + if (now - codel_get_enqueue_time(skb) < p->target || !sch->qstats.backlog) { /* went below - stay below for at least interval */ vars->first_above_time =3D 0; @@ -292,14 +240,14 @@ static bool codel_should_drop(const struct sk_buff *s= kb, /* just went above from below; mark the time */ vars->first_above_time =3D now; - } else if (vars->count > 1 && now - vars->drop_next < 8 * interval) { + } else if (vars->count > 1 && now - vars->drop_next < 8 * p->interval)= { /* we were recently dropping; be more aggressive */ return now > codel_control_law( vars->first_above_time, - interval, + p->interval, vars->rec_inv_sqrt); } else if (((now - vars->first_above_time) >> 15) * - ((now - codel_get_enqueue_time(skb)) >> 15) > threshold) { + ((now - codel_get_enqueue_time(skb)) >> 15) > p->threshold) { return true; } @@ -313,9 +261,7 @@ static inline struct sk_buff *custom_dequeue(struct codel_vars *vars, static struct sk_buff *codel_dequeue(struct Qdisc *sch, struct codel_vars *vars, - codel_time_t interval, - codel_time_t target, - codel_time_t threshold, + struct codel_params *p, bool overloaded) { struct sk_buff *skb =3D custom_dequeue(vars, sch); @@ -327,8 +273,7 @@ static struct sk_buff *codel_dequeue(struct Qdisc *sch, return skb; } now =3D codel_get_time(); - drop =3D codel_should_drop(skb, sch, vars, interval, target, threshold= , - now); + drop =3D codel_should_drop(skb, sch, vars, p, now); if (vars->dropping) { if (!drop) { /* sojourn time below target - leave dropping state */ @@ -350,14 +295,14 @@ static struct sk_buff *codel_dequeue(struct Qdisc *sc= h, codel_Newton_step(vars); vars->drop_next =3D codel_control_law(vars->drop_next, - interval, + p->interval, vars->rec_inv_sqrt); do { if (INET_ECN_set_ce(skb) && !overloaded) { vars->ecn_mark++; /* and schedule the next drop */ vars->drop_next =3D codel_control_law( - vars->drop_next, interval, + vars->drop_next, p->interval, vars->rec_inv_sqrt); goto end; } @@ -365,16 +310,13 @@ static struct sk_buff *codel_dequeue(struct Qdisc *sc= h, vars->drop_count++; skb =3D custom_dequeue(vars, sch); if (skb && !codel_should_drop(skb, sch, vars, - interval, - target, - threshold, - now)) { + p,now)) { /* leave dropping state */ vars->dropping =3D false; } else { /* schedule the next drop */ vars->drop_next =3D codel_control_law(vars->drop_next, - interval, vars->rec_inv_sqrt); + p->interval, vars->rec_inv_sqrt); } } while (skb && vars->dropping && now >=3D vars->drop_next); @@ -391,9 +333,7 @@ static struct sk_buff *codel_dequeue(struct Qdisc *sch, vars->drop_count++; skb =3D custom_dequeue(vars, sch); - drop =3D codel_should_drop(skb, sch, vars, - interval, target, - threshold, now); + drop =3D codel_should_drop(skb, sch, vars, p, now); if (skb && INET_ECN_set_ce(skb)) vars->ecn_mark++; } @@ -403,7 +343,7 @@ static struct sk_buff *codel_dequeue(struct Qdisc *sch, * last cycle is a good starting point to control it now. */ if (vars->count > 2 && - now - vars->drop_next < 8 * interval) { + now - vars->drop_next < 8 * p->interval) { /* when count is halved, time interval is * multiplied by 1.414... */ @@ -415,7 +355,7 @@ static struct sk_buff *codel_dequeue(struct Qdisc *sch, vars->rec_inv_sqrt =3D ~0U >> REC_INV_SQRT_SHIFT; } codel_Newton_step(vars); - vars->drop_next =3D codel_control_law(now, interval, + vars->drop_next =3D codel_control_law(now, p->interval, vars->rec_inv_sqrt); } end: diff --git a/codel_compat.h b/codel_compat.h new file mode 100644 index 0000000..56f83d9 --- /dev/null +++ b/codel_compat.h @@ -0,0 +1,55 @@ +/* Backport some stuff if needed. + */ +#if KERNEL_VERSION(3, 14, 0) > LINUX_VERSION_CODE + +static inline u32 reciprocal_scale(u32 val, u32 ep_ro) +{ + return (u32)(((u64) val * ep_ro) >> 32); +} + +#endif + +#if KERNEL_VERSION(3, 15, 0) > LINUX_VERSION_CODE + +static inline void kvfree(const void *addr) +{ + if (is_vmalloc_addr(addr)) + vfree(addr); + else + kfree(addr); +} + +#endif + +#if KERNEL_VERSION(3, 17, 0) > LINUX_VERSION_CODE + +#define ktime_get_ns() ktime_to_ns(ktime_get()) + +#endif + +#if KERNEL_VERSION(3, 18, 0) > LINUX_VERSION_CODE +static inline void qdisc_qstats_backlog_dec(struct Qdisc *sch, + const struct sk_buff *skb) +{ + sch->qstats.backlog -=3D qdisc_pkt_len(skb); +} + +static inline void qdisc_qstats_backlog_inc(struct Qdisc *sch, + const struct sk_buff *skb) +{ + sch->qstats.backlog +=3D qdisc_pkt_len(skb); +} + +static inline void __qdisc_qstats_drop(struct Qdisc *sch, int count) +{ + sch->qstats.drops +=3D count; +} + +static inline void qdisc_qstats_drop(struct Qdisc *sch) +{ + sch->qstats.drops++; +} + +#define codel_stats_copy_queue(a, b, c, d) gnet_stats_copy_queue(a, c) +#define codel_watchdog_schedule_ns(a, b, c) qdisc_watchdog_schedule_ns(a, = b) +#endif diff --git a/sch_cake.c b/sch_cake.c index 0466ae4..84652cc 100644 --- a/sch_cake.c +++ b/sch_cake.c @@ -118,7 +118,7 @@ struct cake_flow { struct sk_buff *head; struct sk_buff *tail; struct list_head flowchain; - int deficit; + s32 deficit; u32 dropped; /* Drops (or ECN marks) on this flow */ struct codel_vars cvars; }; /* please try to keep this structure <=3D 64 bytes */ @@ -152,7 +152,7 @@ struct cake_tin_data { u16 tin_quantum_prio; u16 tin_quantum_band; - int tin_deficit; + s32 tin_deficit; u32 tin_backlog; u32 tin_dropped; u32 tin_ecn_mark; @@ -185,7 +185,7 @@ struct cake_sched_data { u32 rate_ns; u32 rate_bps; u16 rate_flags; - short rate_overhead; + s16 rate_overhead; u32 interval; u32 target; @@ -414,7 +414,7 @@ static inline u32 cake_overhead(struct cake_sched_data *q, u32 in) } static inline codel_time_t cake_ewma(codel_time_t avg, codel_time_t sample= , - int shift) + u32 shift) { avg -=3D avg >> shift; avg +=3D sample >> shift; @@ -494,7 +494,7 @@ static inline void cake_wash_diffserv(struct sk_buff *s= kb) static inline unsigned int cake_handle_diffserv(struct sk_buff *skb, u16 w= ash) { - unsigned int dscp; + u32 dscp; switch (skb->protocol) { case htons(ETH_P_IP): @@ -517,10 +517,10 @@ static inline unsigned int cake_handle_diffserv(struct sk_buff *skb, u16 wash) static void cake_reconfigure(struct Qdisc *sch); -static int cake_enqueue(struct sk_buff *skb, struct Qdisc *sch) +static s32 cake_enqueue(struct sk_buff *skb, struct Qdisc *sch) { struct cake_sched_data *q =3D qdisc_priv(sch); - unsigned int idx, tin; + u32 idx, tin; struct cake_tin_data *b; struct cake_flow *flow; u32 len =3D qdisc_pkt_len(skb); @@ -563,6 +563,7 @@ static int cake_enqueue(struct sk_buff *skb, struct Qdisc *sch) * or if we need to know individual packet sizes for framing overhead. */ + // FIXME: We always peel at unlimited speed if (unlikely((len * max_t(u32, b->bulk_flow_count, 1U) > q->peel_threshold && skb_is_gso(skb)))) { struct sk_buff *segs, *nskb; @@ -718,7 +719,7 @@ static struct sk_buff *cake_dequeue(struct Qdisc *sch) u32 prev_drop_count, prev_ecn_mark; u32 len; u64 now =3D ktime_get_ns(); - int i; + s32 i; codel_time_t delay; begin: @@ -779,8 +780,7 @@ retry: prev_drop_count =3D flow->cvars.drop_count; prev_ecn_mark =3D flow->cvars.ecn_mark; - skb =3D codel_dequeue(sch, &flow->cvars, b->cparams.interval, - b->cparams.target, b->cparams.threshold, + skb =3D codel_dequeue(sch, &flow->cvars, &b->cparams, q->buffer_used > (q->buffer_limit >> 2) + (q->buffer_limit >> 1)); @@ -838,7 +838,7 @@ retry: static void cake_reset(struct Qdisc *sch) { - int c; + u32 c; for (c =3D 0; c < CAKE_MAX_TINS; c++) cake_clear_tin(sch, c); @@ -900,7 +900,7 @@ static void cake_config_besteffort(struct Qdisc *sch) struct cake_tin_data *b =3D &q->tins[0]; u64 rate =3D q->rate_bps; u32 mtu =3D psched_mtu(qdisc_dev(sch)); - unsigned int i; + u32 i; q->tin_cnt =3D 1; =3D=3D Dave T=C3=A4ht Let's go make home routers and wifi faster! With better software! https://www.gofundme.com/savewifi --001a113d12a4de223b0524f7f87b Content-Type: text/x-patch; charset=US-ASCII; name="cake_ptr.patch" Content-Disposition: attachment; filename="cake_ptr.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_ih7mzgbg0 ZGlmZiAtLWdpdCBhL2NvZGVsNS5oIGIvY29kZWw1LmgKaW5kZXggZDQ1YWE2ZS4uMGMyOTczNSAx MDA2NDQKLS0tIGEvY29kZWw1LmgKKysrIGIvY29kZWw1LmgKQEAgLTU4LDY2ICs1OCwxMyBAQAog ICogSW1wbGVtZW50ZWQgb24gbGludXggYnkgRGF2ZSBUYWh0IGFuZCBFcmljIER1bWF6ZXQKICAq LwogCi0vKiBCYWNrcG9ydCBzb21lIHN0dWZmIGlmIG5lZWRlZC4KLSAqLwotI2lmIEtFUk5FTF9W RVJTSU9OKDMsIDE0LCAwKSA+IExJTlVYX1ZFUlNJT05fQ09ERQotCi1zdGF0aWMgaW5saW5lIHUz MiByZWNpcHJvY2FsX3NjYWxlKHUzMiB2YWwsIHUzMiBlcF9ybykKLXsKLQlyZXR1cm4gKHUzMiko KCh1NjQpIHZhbCAqIGVwX3JvKSA+PiAzMik7Ci19Ci0KLSNlbmRpZgotCi0jaWYgS0VSTkVMX1ZF UlNJT04oMywgMTUsIDApID4gTElOVVhfVkVSU0lPTl9DT0RFCi0KLXN0YXRpYyBpbmxpbmUgdm9p ZCBrdmZyZWUoY29uc3Qgdm9pZCAqYWRkcikKLXsKLQlpZiAoaXNfdm1hbGxvY19hZGRyKGFkZHIp KQotCQl2ZnJlZShhZGRyKTsKLQllbHNlCi0JCWtmcmVlKGFkZHIpOwotfQotCi0jZW5kaWYKLQot I2lmIEtFUk5FTF9WRVJTSU9OKDMsIDE3LCAwKSA+IExJTlVYX1ZFUlNJT05fQ09ERQotCi0jZGVm aW5lIGt0aW1lX2dldF9ucygpIGt0aW1lX3RvX25zKGt0aW1lX2dldCgpKQotCi0jZW5kaWYKLQot I2lmIEtFUk5FTF9WRVJTSU9OKDMsIDE4LCAwKSA+IExJTlVYX1ZFUlNJT05fQ09ERQotc3RhdGlj IGlubGluZSB2b2lkIHFkaXNjX3FzdGF0c19iYWNrbG9nX2RlYyhzdHJ1Y3QgUWRpc2MgKnNjaCwK LQkJCQkJICAgIGNvbnN0IHN0cnVjdCBza19idWZmICpza2IpCi17Ci0Jc2NoLT5xc3RhdHMuYmFj a2xvZyAtPSBxZGlzY19wa3RfbGVuKHNrYik7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdm9pZCBxZGlz Y19xc3RhdHNfYmFja2xvZ19pbmMoc3RydWN0IFFkaXNjICpzY2gsCi0JCQkJCSAgICBjb25zdCBz dHJ1Y3Qgc2tfYnVmZiAqc2tiKQotewotCXNjaC0+cXN0YXRzLmJhY2tsb2cgKz0gcWRpc2NfcGt0 X2xlbihza2IpOwotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQgX19xZGlzY19xc3RhdHNfZHJvcChz dHJ1Y3QgUWRpc2MgKnNjaCwgaW50IGNvdW50KQotewotCXNjaC0+cXN0YXRzLmRyb3BzICs9IGNv dW50OwotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQgcWRpc2NfcXN0YXRzX2Ryb3Aoc3RydWN0IFFk aXNjICpzY2gpCi17Ci0Jc2NoLT5xc3RhdHMuZHJvcHMrKzsKLX0KLQotI2RlZmluZSBjb2RlbF9z dGF0c19jb3B5X3F1ZXVlKGEsIGIsIGMsIGQpIGduZXRfc3RhdHNfY29weV9xdWV1ZShhLCBjKQot I2RlZmluZSBjb2RlbF93YXRjaGRvZ19zY2hlZHVsZV9ucyhhLCBiLCBjKSBxZGlzY193YXRjaGRv Z19zY2hlZHVsZV9ucyhhLCBiKQorI2lmIEtFUk5FTF9WRVJTSU9OKDQsIDIsIDApID4gTElOVVhf VkVSU0lPTl9DT0RFCisjaW5jbHVkZSAiY29kZWw1X2NvbXBhdC5oIgogI2Vsc2UKICNkZWZpbmUg Y29kZWxfc3RhdHNfY29weV9xdWV1ZShhLCBiLCBjLCBkKSBnbmV0X3N0YXRzX2NvcHlfcXVldWUo YSwgYiwgYywgZCkKICNkZWZpbmUgY29kZWxfd2F0Y2hkb2dfc2NoZWR1bGVfbnMoYSwgYiwgYykg cWRpc2Nfd2F0Y2hkb2dfc2NoZWR1bGVfbnMoYSwgYiwgYykKICNlbmRpZgogCi0KIC8qIENvRGVs NSB1c2VzIGEgcmVhbCBjbG9jaywgdW5saWtlIGNvZGVsICovCiAKIHR5cGVkZWYgdTY0IGNvZGVs X3RpbWVfdDsKQEAgLTE5MiwxMSArMTM5LDEzIEBAIHN0cnVjdCBjb2RlbF92YXJzIHsKIAl1MTYJ CWRyb3BfY291bnQ7CiAJdTE2CQllY25fbWFyazsKIH07CisKIC8qIHNpemVvZl9pbl9iaXRzKHJl Y19pbnZfc3FydCkgKi8KICNkZWZpbmUgUkVDX0lOVl9TUVJUX0JJVFMgKDggKiBzaXplb2YodTE2 KSkKIC8qIG5lZWRlZCBzaGlmdCB0byBnZXQgYSBRMC4zMiBudW1iZXIgZnJvbSByZWNfaW52X3Nx cnQgKi8KICNkZWZpbmUgUkVDX0lOVl9TUVJUX1NISUZUICgzMiAtIFJFQ19JTlZfU1FSVF9CSVRT KQotI2RlZmluZSBSRUNfSU5WX1NRUlRfQ0FDSEUgKDE2KQorCisjZGVmaW5lIFJFQ19JTlZfU1FS VF9DQUNIRSAoMTYpIC8vIGZpeG1lIGNhY2hlIGxpbmUgZml4CiAKIC8qIE5ld3RvbiBhcHByb3hp bWF0aW9uIG1ldGhvZCBuZWVkcyBtb3JlIGl0ZXJhdGlvbnMgYXQgc21hbGwgaW5wdXRzLAogICog c28gY2FjaGUgdGhlbS4KQEAgLTIzMiw2ICsxODEsNyBAQCBzdGF0aWMgdm9pZCBjb2RlbF9OZXd0 b25fc3RlcChzdHJ1Y3QgY29kZWxfdmFycyAqdmFycykKIAl9CiB9CiAKKy8vIEZJWE1FIGZvciBw ZWVsIHRocmVzaG9sZAogc3RhdGljIHZvaWQgY29kZWxfY2FjaGVfaW5pdCh2b2lkKQogewogCXN0 cnVjdCBjb2RlbF92YXJzIHY7CkBAIC0yMzksNyArMTg5LDcgQEAgc3RhdGljIHZvaWQgY29kZWxf Y2FjaGVfaW5pdCh2b2lkKQogCWNvZGVsX3ZhcnNfaW5pdCgmdik7CiAJdi5yZWNfaW52X3NxcnQg PSB+MFUgPj4gUkVDX0lOVl9TUVJUX1NISUZUOwogCWNvZGVsX3JlY19pbnZfc3FydF9jYWNoZVsw XSA9IHYucmVjX2ludl9zcXJ0OwotCisJLy9maXhtZSBmb3Igbm8gY2FjaGUKIAlmb3IgKHYuY291 bnQgPSAxOyB2LmNvdW50IDwgUkVDX0lOVl9TUVJUX0NBQ0hFOyB2LmNvdW50KyspIHsKIAkJY29k ZWxfTmV3dG9uX3N0ZXAoJnYpOwogCQljb2RlbF9OZXd0b25fc3RlcCgmdik7CkBAIC0yNjcsOSAr MjE3LDcgQEAgc3RhdGljIGNvZGVsX3RpbWVfdCBjb2RlbF9jb250cm9sX2xhdyhjb2RlbF90aW1l X3QgdCwKIHN0YXRpYyBib29sIGNvZGVsX3Nob3VsZF9kcm9wKGNvbnN0IHN0cnVjdCBza19idWZm ICpza2IsCiAJCQkgICAgICBzdHJ1Y3QgUWRpc2MgKnNjaCwKIAkJCSAgICAgIHN0cnVjdCBjb2Rl bF92YXJzICp2YXJzLAotCQkJICAgICAgY29kZWxfdGltZV90IGludGVydmFsLAotCQkJICAgICAg Y29kZWxfdGltZV90IHRhcmdldCwKLQkJCSAgICAgIGNvZGVsX3RpbWVfdCB0aHJlc2hvbGQsCisJ CQkgICAgICBjb25zdCBzdHJ1Y3QgY29kZWxfcGFyYW1zICpwLAogCQkJICAgICAgY29kZWxfdGlt ZV90IG5vdykKIHsKIAlpZiAoIXNrYikgewpAQCAtMjc5LDcgKzIyNyw3IEBAIHN0YXRpYyBib29s IGNvZGVsX3Nob3VsZF9kcm9wKGNvbnN0IHN0cnVjdCBza19idWZmICpza2IsCiAKIAlzY2gtPnFz dGF0cy5iYWNrbG9nIC09IHFkaXNjX3BrdF9sZW4oc2tiKTsKIAotCWlmIChub3cgLSBjb2RlbF9n ZXRfZW5xdWV1ZV90aW1lKHNrYikgPCB0YXJnZXQgfHwKKwlpZiAobm93IC0gY29kZWxfZ2V0X2Vu cXVldWVfdGltZShza2IpIDwgcC0+dGFyZ2V0IHx8CiAJICAgICFzY2gtPnFzdGF0cy5iYWNrbG9n KSB7CiAJCS8qIHdlbnQgYmVsb3cgLSBzdGF5IGJlbG93IGZvciBhdCBsZWFzdCBpbnRlcnZhbCAq LwogCQl2YXJzLT5maXJzdF9hYm92ZV90aW1lID0gMDsKQEAgLTI5MiwxNCArMjQwLDE0IEBAIHN0 YXRpYyBib29sIGNvZGVsX3Nob3VsZF9kcm9wKGNvbnN0IHN0cnVjdCBza19idWZmICpza2IsCiAJ CS8qIGp1c3Qgd2VudCBhYm92ZSBmcm9tIGJlbG93OyBtYXJrIHRoZSB0aW1lICovCiAJCXZhcnMt PmZpcnN0X2Fib3ZlX3RpbWUgPSBub3c7CiAKLQl9IGVsc2UgaWYgKHZhcnMtPmNvdW50ID4gMSAm JiBub3cgLSB2YXJzLT5kcm9wX25leHQgPCA4ICogaW50ZXJ2YWwpIHsKKwl9IGVsc2UgaWYgKHZh cnMtPmNvdW50ID4gMSAmJiBub3cgLSB2YXJzLT5kcm9wX25leHQgPCA4ICogcC0+aW50ZXJ2YWwp IHsKIAkJLyogd2Ugd2VyZSByZWNlbnRseSBkcm9wcGluZzsgYmUgbW9yZSBhZ2dyZXNzaXZlICov CiAJCXJldHVybiBub3cgPiBjb2RlbF9jb250cm9sX2xhdygKIAkJCQkJCXZhcnMtPmZpcnN0X2Fi b3ZlX3RpbWUsCi0JCQkJCQlpbnRlcnZhbCwKKwkJCQkJCXAtPmludGVydmFsLAogCQkJCQkJdmFy cy0+cmVjX2ludl9zcXJ0KTsKIAl9IGVsc2UgaWYgKCgobm93IC0gdmFycy0+Zmlyc3RfYWJvdmVf dGltZSkgPj4gMTUpICoKLQkJICAgKChub3cgLSBjb2RlbF9nZXRfZW5xdWV1ZV90aW1lKHNrYikp ID4+IDE1KSA+IHRocmVzaG9sZCkgeworCQkgICAoKG5vdyAtIGNvZGVsX2dldF9lbnF1ZXVlX3Rp bWUoc2tiKSkgPj4gMTUpID4gcC0+dGhyZXNob2xkKSB7CiAJCXJldHVybiB0cnVlOwogCX0KIApA QCAtMzEzLDkgKzI2MSw3IEBAIHN0YXRpYyBpbmxpbmUgc3RydWN0IHNrX2J1ZmYgKmN1c3RvbV9k ZXF1ZXVlKHN0cnVjdCBjb2RlbF92YXJzICp2YXJzLAogCiBzdGF0aWMgc3RydWN0IHNrX2J1ZmYg KmNvZGVsX2RlcXVldWUoc3RydWN0IFFkaXNjICpzY2gsCiAJCQkJICAgICBzdHJ1Y3QgY29kZWxf dmFycyAqdmFycywKLQkJCQkgICAgIGNvZGVsX3RpbWVfdCBpbnRlcnZhbCwKLQkJCQkgICAgIGNv ZGVsX3RpbWVfdCB0YXJnZXQsCi0JCQkJICAgICBjb2RlbF90aW1lX3QgdGhyZXNob2xkLAorCQkJ CSAgICAgc3RydWN0IGNvZGVsX3BhcmFtcyAqcCwKIAkJCQkgICAgIGJvb2wgb3ZlcmxvYWRlZCkK IHsKIAlzdHJ1Y3Qgc2tfYnVmZiAqc2tiID0gY3VzdG9tX2RlcXVldWUodmFycywgc2NoKTsKQEAg LTMyNyw4ICsyNzMsNyBAQCBzdGF0aWMgc3RydWN0IHNrX2J1ZmYgKmNvZGVsX2RlcXVldWUoc3Ry dWN0IFFkaXNjICpzY2gsCiAJCXJldHVybiBza2I7CiAJfQogCW5vdyA9IGNvZGVsX2dldF90aW1l KCk7Ci0JZHJvcCA9IGNvZGVsX3Nob3VsZF9kcm9wKHNrYiwgc2NoLCB2YXJzLCBpbnRlcnZhbCwg dGFyZ2V0LCB0aHJlc2hvbGQsCi0JCQkJIG5vdyk7CisJZHJvcCA9IGNvZGVsX3Nob3VsZF9kcm9w KHNrYiwgc2NoLCB2YXJzLCBwLCBub3cpOwogCWlmICh2YXJzLT5kcm9wcGluZykgewogCQlpZiAo IWRyb3ApIHsKIAkJCS8qIHNvam91cm4gdGltZSBiZWxvdyB0YXJnZXQgLSBsZWF2ZSBkcm9wcGlu ZyBzdGF0ZSAqLwpAQCAtMzUwLDE0ICsyOTUsMTQgQEAgc3RhdGljIHN0cnVjdCBza19idWZmICpj b2RlbF9kZXF1ZXVlKHN0cnVjdCBRZGlzYyAqc2NoLAogCiAJCQljb2RlbF9OZXd0b25fc3RlcCh2 YXJzKTsKIAkJCXZhcnMtPmRyb3BfbmV4dCA9IGNvZGVsX2NvbnRyb2xfbGF3KHZhcnMtPmRyb3Bf bmV4dCwKLQkJCQkJCQkgICAgaW50ZXJ2YWwsCisJCQkJCQkJICAgIHAtPmludGVydmFsLAogCQkJ CQkJCSAgICB2YXJzLT5yZWNfaW52X3NxcnQpOwogCQkJZG8gewogCQkJCWlmIChJTkVUX0VDTl9z ZXRfY2Uoc2tiKSAmJiAhb3ZlcmxvYWRlZCkgewogCQkJCQl2YXJzLT5lY25fbWFyaysrOwogCQkJ CQkvKiBhbmQgc2NoZWR1bGUgdGhlIG5leHQgZHJvcCAqLwogCQkJCQl2YXJzLT5kcm9wX25leHQg PSBjb2RlbF9jb250cm9sX2xhdygKLQkJCQkJCXZhcnMtPmRyb3BfbmV4dCwgaW50ZXJ2YWwsCisJ CQkJCQl2YXJzLT5kcm9wX25leHQsIHAtPmludGVydmFsLAogCQkJCQkJdmFycy0+cmVjX2ludl9z cXJ0KTsKIAkJCQkJZ290byBlbmQ7CiAJCQkJfQpAQCAtMzY1LDE2ICszMTAsMTMgQEAgc3RhdGlj IHN0cnVjdCBza19idWZmICpjb2RlbF9kZXF1ZXVlKHN0cnVjdCBRZGlzYyAqc2NoLAogCQkJCXZh cnMtPmRyb3BfY291bnQrKzsKIAkJCQlza2IgPSBjdXN0b21fZGVxdWV1ZSh2YXJzLCBzY2gpOwog CQkJCWlmIChza2IgJiYgIWNvZGVsX3Nob3VsZF9kcm9wKHNrYiwgc2NoLCB2YXJzLAotCQkJCQkJ CSAgICAgIGludGVydmFsLAotCQkJCQkJCSAgICAgIHRhcmdldCwKLQkJCQkJCQkgICAgICB0aHJl c2hvbGQsCi0JCQkJCQkJICAgICAgbm93KSkgeworCQkJCQkJCSAgICAgIHAsbm93KSkgewogCQkJ CQkvKiBsZWF2ZSBkcm9wcGluZyBzdGF0ZSAqLwogCQkJCQl2YXJzLT5kcm9wcGluZyA9IGZhbHNl OwogCQkJCX0gZWxzZSB7CiAJCQkJCS8qIHNjaGVkdWxlIHRoZSBuZXh0IGRyb3AgKi8KIAkJCQkJ dmFycy0+ZHJvcF9uZXh0ID0gY29kZWxfY29udHJvbF9sYXcodmFycy0+ZHJvcF9uZXh0LAotCQkJ CQkJCQkgIGludGVydmFsLCB2YXJzLT5yZWNfaW52X3NxcnQpOworCQkJCQkJCQkgIHAtPmludGVy dmFsLCB2YXJzLT5yZWNfaW52X3NxcnQpOwogCQkJCX0KIAkJCX0gd2hpbGUgKHNrYiAmJiB2YXJz LT5kcm9wcGluZyAmJiBub3cgPj0KIAkJCQkgdmFycy0+ZHJvcF9uZXh0KTsKQEAgLTM5MSw5ICsz MzMsNyBAQCBzdGF0aWMgc3RydWN0IHNrX2J1ZmYgKmNvZGVsX2RlcXVldWUoc3RydWN0IFFkaXNj ICpzY2gsCiAJCQl2YXJzLT5kcm9wX2NvdW50Kys7CiAKIAkJCXNrYiA9IGN1c3RvbV9kZXF1ZXVl KHZhcnMsIHNjaCk7Ci0JCQlkcm9wID0gY29kZWxfc2hvdWxkX2Ryb3Aoc2tiLCBzY2gsIHZhcnMs Ci0JCQkJCQkgaW50ZXJ2YWwsIHRhcmdldCwKLQkJCQkJCSB0aHJlc2hvbGQsIG5vdyk7CisJCQlk cm9wID0gY29kZWxfc2hvdWxkX2Ryb3Aoc2tiLCBzY2gsIHZhcnMsIHAsIG5vdyk7CiAJCQlpZiAo c2tiICYmIElORVRfRUNOX3NldF9jZShza2IpKQogCQkJCXZhcnMtPmVjbl9tYXJrKys7CiAJCX0K QEAgLTQwMyw3ICszNDMsNyBAQCBzdGF0aWMgc3RydWN0IHNrX2J1ZmYgKmNvZGVsX2RlcXVldWUo c3RydWN0IFFkaXNjICpzY2gsCiAJCSAqIGxhc3QgY3ljbGUgaXMgYSBnb29kIHN0YXJ0aW5nIHBv aW50IHRvIGNvbnRyb2wgaXQgbm93LgogCQkgKi8KIAkJaWYgKHZhcnMtPmNvdW50ID4gMiAmJgot CQkgICAgbm93IC0gdmFycy0+ZHJvcF9uZXh0IDwgOCAqIGludGVydmFsKSB7CisJCSAgICBub3cg LSB2YXJzLT5kcm9wX25leHQgPCA4ICogcC0+aW50ZXJ2YWwpIHsKIAkJCS8qIHdoZW4gY291bnQg aXMgaGFsdmVkLCB0aW1lIGludGVydmFsIGlzCiAJCQkgKiBtdWx0aXBsaWVkIGJ5IDEuNDE0Li4u CiAJCQkgKi8KQEAgLTQxNSw3ICszNTUsNyBAQCBzdGF0aWMgc3RydWN0IHNrX2J1ZmYgKmNvZGVs X2RlcXVldWUoc3RydWN0IFFkaXNjICpzY2gsCiAJCQl2YXJzLT5yZWNfaW52X3NxcnQgPSB+MFUg Pj4gUkVDX0lOVl9TUVJUX1NISUZUOwogCQl9CiAJCWNvZGVsX05ld3Rvbl9zdGVwKHZhcnMpOwot CQl2YXJzLT5kcm9wX25leHQgPSBjb2RlbF9jb250cm9sX2xhdyhub3csIGludGVydmFsLAorCQl2 YXJzLT5kcm9wX25leHQgPSBjb2RlbF9jb250cm9sX2xhdyhub3csIHAtPmludGVydmFsLAogCQkJ CQkJICAgIHZhcnMtPnJlY19pbnZfc3FydCk7CiAJfQogZW5kOgpkaWZmIC0tZ2l0IGEvY29kZWxf Y29tcGF0LmggYi9jb2RlbF9jb21wYXQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwLi41NmY4M2Q5Ci0tLSAvZGV2L251bGwKKysrIGIvY29kZWxfY29tcGF0LmgKQEAgLTAsMCAr MSw1NSBAQAorLyogQmFja3BvcnQgc29tZSBzdHVmZiBpZiBuZWVkZWQuCisgKi8KKyNpZiBLRVJO RUxfVkVSU0lPTigzLCAxNCwgMCkgPiBMSU5VWF9WRVJTSU9OX0NPREUKKworc3RhdGljIGlubGlu ZSB1MzIgcmVjaXByb2NhbF9zY2FsZSh1MzIgdmFsLCB1MzIgZXBfcm8pCit7CisJcmV0dXJuICh1 MzIpKCgodTY0KSB2YWwgKiBlcF9ybykgPj4gMzIpOworfQorCisjZW5kaWYKKworI2lmIEtFUk5F TF9WRVJTSU9OKDMsIDE1LCAwKSA+IExJTlVYX1ZFUlNJT05fQ09ERQorCitzdGF0aWMgaW5saW5l IHZvaWQga3ZmcmVlKGNvbnN0IHZvaWQgKmFkZHIpCit7CisJaWYgKGlzX3ZtYWxsb2NfYWRkcihh ZGRyKSkKKwkJdmZyZWUoYWRkcik7CisJZWxzZQorCQlrZnJlZShhZGRyKTsKK30KKworI2VuZGlm CisKKyNpZiBLRVJORUxfVkVSU0lPTigzLCAxNywgMCkgPiBMSU5VWF9WRVJTSU9OX0NPREUKKwor I2RlZmluZSBrdGltZV9nZXRfbnMoKSBrdGltZV90b19ucyhrdGltZV9nZXQoKSkKKworI2VuZGlm CisKKyNpZiBLRVJORUxfVkVSU0lPTigzLCAxOCwgMCkgPiBMSU5VWF9WRVJTSU9OX0NPREUKK3N0 YXRpYyBpbmxpbmUgdm9pZCBxZGlzY19xc3RhdHNfYmFja2xvZ19kZWMoc3RydWN0IFFkaXNjICpz Y2gsCisJCQkJCSAgICBjb25zdCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQoreworCXNjaC0+cXN0YXRz LmJhY2tsb2cgLT0gcWRpc2NfcGt0X2xlbihza2IpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQg cWRpc2NfcXN0YXRzX2JhY2tsb2dfaW5jKHN0cnVjdCBRZGlzYyAqc2NoLAorCQkJCQkgICAgY29u c3Qgc3RydWN0IHNrX2J1ZmYgKnNrYikKK3sKKwlzY2gtPnFzdGF0cy5iYWNrbG9nICs9IHFkaXNj X3BrdF9sZW4oc2tiKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIF9fcWRpc2NfcXN0YXRzX2Ry b3Aoc3RydWN0IFFkaXNjICpzY2gsIGludCBjb3VudCkKK3sKKwlzY2gtPnFzdGF0cy5kcm9wcyAr PSBjb3VudDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHFkaXNjX3FzdGF0c19kcm9wKHN0cnVj dCBRZGlzYyAqc2NoKQoreworCXNjaC0+cXN0YXRzLmRyb3BzKys7Cit9CisKKyNkZWZpbmUgY29k ZWxfc3RhdHNfY29weV9xdWV1ZShhLCBiLCBjLCBkKSBnbmV0X3N0YXRzX2NvcHlfcXVldWUoYSwg YykKKyNkZWZpbmUgY29kZWxfd2F0Y2hkb2dfc2NoZWR1bGVfbnMoYSwgYiwgYykgcWRpc2Nfd2F0 Y2hkb2dfc2NoZWR1bGVfbnMoYSwgYikKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvc2NoX2Nha2UuYyBi L3NjaF9jYWtlLmMKaW5kZXggMDQ2NmFlNC4uODQ2NTJjYyAxMDA2NDQKLS0tIGEvc2NoX2Nha2Uu YworKysgYi9zY2hfY2FrZS5jCkBAIC0xMTgsNyArMTE4LDcgQEAgc3RydWN0IGNha2VfZmxvdyB7 CiAJc3RydWN0IHNrX2J1ZmYJICAqaGVhZDsKIAlzdHJ1Y3Qgc2tfYnVmZgkgICp0YWlsOwogCXN0 cnVjdCBsaXN0X2hlYWQgIGZsb3djaGFpbjsKLQlpbnQJCSAgZGVmaWNpdDsKKwlzMzIJCSAgZGVm aWNpdDsKIAl1MzIJCSAgZHJvcHBlZDsgLyogRHJvcHMgKG9yIEVDTiBtYXJrcykgb24gdGhpcyBm bG93ICovCiAJc3RydWN0IGNvZGVsX3ZhcnMgY3ZhcnM7CiB9OyAvKiBwbGVhc2UgdHJ5IHRvIGtl ZXAgdGhpcyBzdHJ1Y3R1cmUgPD0gNjQgYnl0ZXMgKi8KQEAgLTE1Miw3ICsxNTIsNyBAQCBzdHJ1 Y3QgY2FrZV90aW5fZGF0YSB7CiAKIAl1MTYJdGluX3F1YW50dW1fcHJpbzsKIAl1MTYJdGluX3F1 YW50dW1fYmFuZDsKLQlpbnQJdGluX2RlZmljaXQ7CisJczMyCXRpbl9kZWZpY2l0OwogCXUzMgl0 aW5fYmFja2xvZzsKIAl1MzIJdGluX2Ryb3BwZWQ7CiAJdTMyCXRpbl9lY25fbWFyazsKQEAgLTE4 NSw3ICsxODUsNyBAQCBzdHJ1Y3QgY2FrZV9zY2hlZF9kYXRhIHsKIAl1MzIJCXJhdGVfbnM7CiAJ dTMyCQlyYXRlX2JwczsKIAl1MTYJCXJhdGVfZmxhZ3M7Ci0Jc2hvcnQJCXJhdGVfb3ZlcmhlYWQ7 CisJczE2CQlyYXRlX292ZXJoZWFkOwogCXUzMgkJaW50ZXJ2YWw7CiAJdTMyCQl0YXJnZXQ7CiAK QEAgLTQxNCw3ICs0MTQsNyBAQCBzdGF0aWMgaW5saW5lIHUzMiBjYWtlX292ZXJoZWFkKHN0cnVj dCBjYWtlX3NjaGVkX2RhdGEgKnEsIHUzMiBpbikKIH0KIAogc3RhdGljIGlubGluZSBjb2RlbF90 aW1lX3QgY2FrZV9ld21hKGNvZGVsX3RpbWVfdCBhdmcsIGNvZGVsX3RpbWVfdCBzYW1wbGUsCi0J CQkJICAgICBpbnQgc2hpZnQpCisJCQkJICAgICB1MzIgc2hpZnQpCiB7CiAJYXZnIC09IGF2ZyA+ PiBzaGlmdDsKIAlhdmcgKz0gc2FtcGxlID4+IHNoaWZ0OwpAQCAtNDk0LDcgKzQ5NCw3IEBAIHN0 YXRpYyBpbmxpbmUgdm9pZCBjYWtlX3dhc2hfZGlmZnNlcnYoc3RydWN0IHNrX2J1ZmYgKnNrYikK IAogc3RhdGljIGlubGluZSB1bnNpZ25lZCBpbnQgY2FrZV9oYW5kbGVfZGlmZnNlcnYoc3RydWN0 IHNrX2J1ZmYgKnNrYiwgdTE2IHdhc2gpCiB7Ci0JdW5zaWduZWQgaW50IGRzY3A7CisJdTMyIGRz Y3A7CiAKIAlzd2l0Y2ggKHNrYi0+cHJvdG9jb2wpIHsKIAljYXNlIGh0b25zKEVUSF9QX0lQKToK QEAgLTUxNywxMCArNTE3LDEwIEBAIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgaW50IGNha2VfaGFu ZGxlX2RpZmZzZXJ2KHN0cnVjdCBza19idWZmICpza2IsIHUxNiB3YXNoKQogCiBzdGF0aWMgdm9p ZCBjYWtlX3JlY29uZmlndXJlKHN0cnVjdCBRZGlzYyAqc2NoKTsKIAotc3RhdGljIGludCBjYWtl X2VucXVldWUoc3RydWN0IHNrX2J1ZmYgKnNrYiwgc3RydWN0IFFkaXNjICpzY2gpCitzdGF0aWMg czMyIGNha2VfZW5xdWV1ZShzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBzdHJ1Y3QgUWRpc2MgKnNjaCkK IHsKIAlzdHJ1Y3QgY2FrZV9zY2hlZF9kYXRhICpxID0gcWRpc2NfcHJpdihzY2gpOwotCXVuc2ln bmVkIGludCBpZHgsIHRpbjsKKwl1MzIgaWR4LCB0aW47CiAJc3RydWN0IGNha2VfdGluX2RhdGEg KmI7CiAJc3RydWN0IGNha2VfZmxvdyAqZmxvdzsKIAl1MzIgbGVuID0gcWRpc2NfcGt0X2xlbihz a2IpOwpAQCAtNTYzLDYgKzU2Myw3IEBAIHN0YXRpYyBpbnQgY2FrZV9lbnF1ZXVlKHN0cnVjdCBz a19idWZmICpza2IsIHN0cnVjdCBRZGlzYyAqc2NoKQogCSAqIG9yIGlmIHdlIG5lZWQgdG8ga25v dyBpbmRpdmlkdWFsIHBhY2tldCBzaXplcyBmb3IgZnJhbWluZyBvdmVyaGVhZC4KIAkgKi8KIAor CS8vIEZJWE1FOiBXZSBhbHdheXMgcGVlbCBhdCB1bmxpbWl0ZWQgc3BlZWQKIAlpZiAodW5saWtl bHkoKGxlbiAqIG1heF90KHUzMiwgYi0+YnVsa19mbG93X2NvdW50LCAxVSkgPgogCQkgICAgICBx LT5wZWVsX3RocmVzaG9sZCAmJiBza2JfaXNfZ3NvKHNrYikpKSkgewogCQlzdHJ1Y3Qgc2tfYnVm ZiAqc2VncywgKm5za2I7CkBAIC03MTgsNyArNzE5LDcgQEAgc3RhdGljIHN0cnVjdCBza19idWZm ICpjYWtlX2RlcXVldWUoc3RydWN0IFFkaXNjICpzY2gpCiAJdTMyIHByZXZfZHJvcF9jb3VudCwg cHJldl9lY25fbWFyazsKIAl1MzIgbGVuOwogCXU2NCBub3cgPSBrdGltZV9nZXRfbnMoKTsKLQlp bnQgaTsKKwlzMzIgaTsKIAljb2RlbF90aW1lX3QgZGVsYXk7CiAKIGJlZ2luOgpAQCAtNzc5LDgg Kzc4MCw3IEBAIHJldHJ5OgogCXByZXZfZHJvcF9jb3VudCA9IGZsb3ctPmN2YXJzLmRyb3BfY291 bnQ7CiAJcHJldl9lY25fbWFyayAgID0gZmxvdy0+Y3ZhcnMuZWNuX21hcms7CiAKLQlza2IgPSBj b2RlbF9kZXF1ZXVlKHNjaCwgJmZsb3ctPmN2YXJzLCBiLT5jcGFyYW1zLmludGVydmFsLAotCQkJ ICAgIGItPmNwYXJhbXMudGFyZ2V0LCBiLT5jcGFyYW1zLnRocmVzaG9sZCwKKwlza2IgPSBjb2Rl bF9kZXF1ZXVlKHNjaCwgJmZsb3ctPmN2YXJzLCAmYi0+Y3BhcmFtcywKIAkJCSAgICBxLT5idWZm ZXJfdXNlZCA+CiAJCQkgICAgKHEtPmJ1ZmZlcl9saW1pdCA+PiAyKSArIChxLT5idWZmZXJfbGlt aXQgPj4gMSkpOwogCkBAIC04MzgsNyArODM4LDcgQEAgcmV0cnk6CiAKIHN0YXRpYyB2b2lkIGNh a2VfcmVzZXQoc3RydWN0IFFkaXNjICpzY2gpCiB7Ci0JaW50IGM7CisJdTMyIGM7CiAKIAlmb3Ig KGMgPSAwOyBjIDwgQ0FLRV9NQVhfVElOUzsgYysrKQogCQljYWtlX2NsZWFyX3RpbihzY2gsIGMp OwpAQCAtOTAwLDcgKzkwMCw3IEBAIHN0YXRpYyB2b2lkIGNha2VfY29uZmlnX2Jlc3RlZmZvcnQo c3RydWN0IFFkaXNjICpzY2gpCiAJc3RydWN0IGNha2VfdGluX2RhdGEgKmIgPSAmcS0+dGluc1sw XTsKIAl1NjQgcmF0ZSA9IHEtPnJhdGVfYnBzOwogCXUzMiBtdHUgPSBwc2NoZWRfbXR1KHFkaXNj X2RldihzY2gpKTsKLQl1bnNpZ25lZCBpbnQgaTsKKwl1MzIgaTsKIAogCXEtPnRpbl9jbnQgPSAx OwogCg== --001a113d12a4de223b0524f7f87b--