From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754082AbdGJNEN (ORCPT ); Mon, 10 Jul 2017 09:04:13 -0400 Received: from mga11.intel.com ([192.55.52.93]:35702 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753800AbdGJNEL (ORCPT ); Mon, 10 Jul 2017 09:04:11 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.40,340,1496127600"; d="scan'208";a="1193555599" From: Alexey Budankov Subject: [PATCH v5 4/4]: perf/core: complete replace of lists by rb trees for pinned and flexible groups at perf_event_context Organization: Intel Corp. To: Peter Zijlstra , Ingo Molnar , Arnaldo Carvalho de Melo , Alexander Shishkin Cc: Andi Kleen , Kan Liang , Dmitri Prokhorov , Valery Cherepennikov , Mark Rutland , David Carrillo-Cisneros , Stephane Eranian , linux-kernel Message-ID: Date: Mon, 10 Jul 2017 16:03:49 +0300 User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Thunderbird/52.2.1 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="------------68C52A70A0F669AA86980081" Content-Language: en-US Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This is a multi-part message in MIME format. --------------68C52A70A0F669AA86980081 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 7bit perf/core: complete replace of lists by rb trees for pinned and flexible groups at perf_event_context By default, the userspace perf tool opens per-cpu task-bound events when sampling, so for N logical events requested by the user, the tool will open N * NR_CPUS events. In the kernel, we mux events with a hrtimer, periodically rotating the flexible group list and trying to schedule each group in turn. We skip groups whose cpu filter doesn't match. So when we get unlucky, we can walk N * (NR_CPUS - 1) groups pointlessly for each hrtimer invocation. This has been observed to result in significant overhead when running the STREAM benchmark on 272 core Xeon Phi systems. One way to avoid this is to place our events into an rb tree sorted by CPU filter, so that our hrtimer can skip to the current CPU's list and ignore everything else. This patch implements complete replacement of lists by rb trees for pinned and flexible groups. The patch set was tested on Xeon Phi using perf_fuzzer and tests from here: https://github.com/deater/perf_event_tests The full patch set (v1-4) is attached for convenience. Branch revision: * perf/core 007b811b4041989ec2dc91b9614aa2c41332723e Merge tag 'perf-core-for-mingo-4.13-20170719' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux into perf/core Signed-off-by: Alexey Budankov --- include/linux/perf_event.h | 20 +--------- kernel/events/core.c | 94 ++++++++++++++++------------------------------ 2 files changed, 34 insertions(+), 80 deletions(-) diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h index 7b2cddf..8e1967f 100644 --- a/include/linux/perf_event.h +++ b/include/linux/perf_event.h @@ -603,13 +603,6 @@ struct perf_event { */ struct list_head group_list; /* - * Entry into the group_list list above; - * the entry may be attached to the self group_list list above - * in case the event is directly attached to the tree; - */ - struct list_head group_list_entry; - - /* * We need storage to track the entries in perf_pmu_migrate_context; we * cannot use the event_entry because of RCU and we want to keep the * group in tact which avoids us using the other two entries. @@ -749,15 +742,6 @@ struct perf_event { #endif /* CONFIG_PERF_EVENTS */ }; -/* - * event groups keep group leader events arranged as an rb tree with - * event->cpu key and as a list for the whole tree iterations; - */ -struct perf_event_groups { - struct list_head list; - struct rb_root tree; -}; - /** * struct perf_event_context - event context structure * @@ -778,8 +762,8 @@ struct perf_event_context { struct mutex mutex; struct list_head active_ctx_list; - struct perf_event_groups pinned_groups; - struct perf_event_groups flexible_groups; + struct rb_root pinned_groups; + struct rb_root flexible_groups; struct list_head event_list; int nr_events; int nr_active; diff --git a/kernel/events/core.c b/kernel/events/core.c index bddcb87..5142434 100644 --- a/kernel/events/core.c +++ b/kernel/events/core.c @@ -1466,7 +1466,7 @@ static enum event_type_t get_event_type(struct perf_event *event) * Extract pinned or flexible groups from the context * based on event attrs bits; */ -static struct perf_event_groups * +static struct rb_root * get_event_groups(struct perf_event *event, struct perf_event_context *ctx) { if (event->attr.pinned) @@ -1476,11 +1476,11 @@ get_event_groups(struct perf_event *event, struct perf_event_context *ctx) } static void -perf_event_groups_insert(struct perf_event_groups *groups, +perf_event_groups_insert(struct rb_root *groups, struct perf_event *event); static void -perf_event_groups_delete(struct perf_event_groups *groups, +perf_event_groups_delete(struct rb_root *groups, struct perf_event *event); /* @@ -1490,7 +1490,7 @@ perf_event_groups_delete(struct perf_event_groups *groups, static void add_event_to_groups(struct perf_event *event, struct perf_event_context *ctx) { - struct perf_event_groups *groups; + struct rb_root *groups; groups = get_event_groups(event, ctx); perf_event_groups_insert(groups, event); @@ -1502,48 +1502,28 @@ add_event_to_groups(struct perf_event *event, struct perf_event_context *ctx) static void del_event_from_groups(struct perf_event *event, struct perf_event_context *ctx) { - struct perf_event_groups *groups; + struct rb_root *groups; groups = get_event_groups(event, ctx); perf_event_groups_delete(groups, event); } /* - * Helper function to test if event groups are empty; - */ -static int -perf_event_groups_empty(struct perf_event_groups *groups) -{ - return list_empty(&groups->list); -} - -/* - * Helper function to Initialize event groups object; - */ -static void -perf_event_groups_init(struct perf_event_groups *groups) -{ - INIT_LIST_HEAD(&groups->list); - groups->tree = RB_ROOT; -} - -/* * Insert a group into a tree using event->cpu as a key. If event->cpu node * is already attached to the tree then the event is added to the attached * group's group_list list. */ static void -perf_event_groups_insert(struct perf_event_groups *groups, - struct perf_event *event) +perf_event_groups_insert(struct rb_root *groups, struct perf_event *event) { struct rb_node **node; struct rb_node *parent; struct perf_event *node_event; WARN_ON_ONCE(!groups || !event); - WARN_ON_ONCE(!list_empty(&event->group_list_entry)); + WARN_ON_ONCE(!list_empty(&event->group_entry)); - node = &groups->tree.rb_node; + node = &groups->rb_node; parent = *node; while (*node) { @@ -1556,16 +1536,16 @@ perf_event_groups_insert(struct perf_event_groups *groups, } else if (event->cpu > node_event->cpu) { node = &parent->rb_right; } else { - list_add_tail(&event->group_list_entry, + list_add_tail(&event->group_entry, &node_event->group_list); return; } } - list_add_tail(&event->group_list_entry, &event->group_list); + list_add_tail(&event->group_entry, &event->group_list); rb_link_node(&event->group_node, parent, node); - rb_insert_color(&event->group_node, &groups->tree); + rb_insert_color(&event->group_node, groups); } /* @@ -1573,30 +1553,28 @@ perf_event_groups_insert(struct perf_event_groups *groups, * it also detaches all groups on the group's group_list list. */ static void -perf_event_groups_delete(struct perf_event_groups *groups, - struct perf_event *event) +perf_event_groups_delete(struct rb_root *groups, struct perf_event *event) { struct perf_event *next; WARN_ON_ONCE(!event); - WARN_ON_ONCE(list_empty(&event->group_list_entry)); + WARN_ON_ONCE(list_empty(&event->group_entry)); - list_del_init(&event->group_list_entry); + list_del_init(&event->group_entry); if (!RB_EMPTY_NODE(&event->group_node)) { WARN_ON_ONCE(!groups); - if (!RB_EMPTY_ROOT(&groups->tree)) { + if (!RB_EMPTY_ROOT(groups)) { if (list_empty(&event->group_list)) { rb_erase(&event->group_node, &groups->tree); } else { next = list_first_entry(&event->group_list, - struct perf_event, group_list_entry); + struct perf_event, group_entry); list_replace_init(&event->group_list, &next->group_list); rb_replace_node(&event->group_node, - &next->group_node, &groups->tree); + &next->group_node, groups); } - } RB_CLEAR_NODE(&event->group_node); } @@ -1606,14 +1584,14 @@ perf_event_groups_delete(struct perf_event_groups *groups, * Find group list by a cpu key and rotate it. */ static void -perf_event_groups_rotate(struct perf_event_groups *groups, int cpu) +perf_event_groups_rotate(struct rb_root *groups, int cpu) { struct rb_node *node; struct perf_event *node_event; WARN_ON_ONCE(!groups); - node = groups->tree.rb_node; + node = groups->rb_node; while (node) { node_event = container_of(node, @@ -1638,7 +1616,7 @@ perf_event_groups_rotate(struct perf_event_groups *groups, int cpu) typedef int(*perf_event_groups_iterate_f)(struct perf_event *, void *); static void -perf_event_groups_iterate_cpu(struct perf_event_groups *groups, int cpu, +perf_event_groups_iterate_cpu(struct rb_root *groups, int cpu, perf_event_groups_iterate_f callback, void *data) { struct rb_node *node; @@ -1646,7 +1624,7 @@ perf_event_groups_iterate_cpu(struct perf_event_groups *groups, int cpu, WARN_ON_ONCE(!groups); - node = groups->tree.rb_node; + node = groups->rb_node; while (node) { node_event = container_of(node, @@ -1658,7 +1636,7 @@ perf_event_groups_iterate_cpu(struct perf_event_groups *groups, int cpu, node = node->rb_right; } else { list_for_each_entry(event, &node_event->group_list, - group_list_entry) + group_entry) callback(event, data); break; } @@ -1670,26 +1648,20 @@ perf_event_groups_iterate_cpu(struct perf_event_groups *groups, int cpu, * Iteration stops if the callback returns non zero. */ static int -perf_event_groups_iterate(struct perf_event_groups *groups, +perf_event_groups_iterate(struct rb_root *groups, perf_event_groups_iterate_f callback, void *data) { int ret = 0; - struct perf_event *event; + struct rb_node *node; - WARN_ON_ONCE(!groups); + struct perf_event *node_event, *event; - list_for_each_entry(event, &groups->list, group_list_entry) { - ret = callback(event, data); - if (ret) - break; - } - - /* will replace itration above in patch v5 4/4 + WARN_ON_ONCE(!groups); for (node = rb_first(groups); node; node = rb_next(node)) { node_event = container_of(node, struct perf_event, group_node); list_for_each_entry(event, &node_event->group_list, - group_list_entry) { + group_entry) { WARN_ON_ONCE(!(event->cpu == node_event->cpu)); ret = callback(event, data); if (ret) { @@ -1698,8 +1670,6 @@ perf_event_groups_iterate(struct perf_event_groups *groups, } } - */ - return ret; } @@ -2965,7 +2935,9 @@ static void ctx_sched_out(struct perf_event_context *ctx, .cpuctx = cpuctx, .ctx = ctx }; + int cpu = smp_processor_id(); + lockdep_assert_held(&ctx->lock); if (likely(!ctx->nr_events)) { @@ -3399,7 +3371,6 @@ ctx_sched_in(struct perf_event_context *ctx, .ctx = ctx }; int cpu = smp_processor_id(); - lockdep_assert_held(&ctx->lock); if (likely(!ctx->nr_events)) @@ -3490,7 +3461,7 @@ static void perf_event_context_sched_in(struct perf_event_context *ctx, * However, if task's ctx is not carrying any pinned * events, no need to flip the cpuctx's events around. */ - if (!perf_event_groups_empty(&ctx->pinned_groups)) + if (!RB_EMPTY_ROOT(&ctx->pinned_groups)) cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE, mux); perf_event_sched_in(cpuctx, ctx, task, mux); perf_pmu_enable(ctx->pmu); @@ -4057,8 +4028,8 @@ static void __perf_event_init_context(struct perf_event_context *ctx) raw_spin_lock_init(&ctx->lock); mutex_init(&ctx->mutex); INIT_LIST_HEAD(&ctx->active_ctx_list); - perf_event_groups_init(&ctx->pinned_groups); - perf_event_groups_init(&ctx->flexible_groups); + ctx->pinned_groups = RB_ROOT; + ctx->flexible_groups = RB_ROOT; INIT_LIST_HEAD(&ctx->event_list); atomic_set(&ctx->refcount, 1); } @@ -9695,7 +9666,6 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu, INIT_LIST_HEAD(&event->sibling_list); RB_CLEAR_NODE(&event->group_node); INIT_LIST_HEAD(&event->group_list); - INIT_LIST_HEAD(&event->group_list_entry); INIT_LIST_HEAD(&event->rb_entry); INIT_LIST_HEAD(&event->active_entry); INIT_LIST_HEAD(&event->addr_filters.list); --------------68C52A70A0F669AA86980081 Content-Type: text/plain; charset=UTF-8; name="v5-n.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="v5-n.patch" IGluY2x1ZGUvbGludXgvcGVyZl9ldmVudC5oIHwgIDU1ICsrKy0tCiBrZXJuZWwvZXZlbnRz L2NvcmUuYyAgICAgICB8IDYwNCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKyst LS0tLS0tLS0tLS0KIDIgZmlsZXMgY2hhbmdlZCwgNDkxIGluc2VydGlvbnMoKyksIDE2OCBk ZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3BlcmZfZXZlbnQuaCBi L2luY2x1ZGUvbGludXgvcGVyZl9ldmVudC5oCmluZGV4IDI0YTYzNTguLjhlMTk2N2YgMTAw NjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvcGVyZl9ldmVudC5oCisrKyBiL2luY2x1ZGUvbGlu dXgvcGVyZl9ldmVudC5oCkBAIC01NTAsNiArNTUwLDIyIEBAIHN0cnVjdCBwbXVfZXZlbnRf bGlzdCB7CiAJc3RydWN0IGxpc3RfaGVhZAlsaXN0OwogfTsKIAorc3RydWN0IHBlcmZfZXZl bnRfdHN0YW1wIHsKKwkvKgorCSAqIFRoZXNlIGFyZSB0aW1lc3RhbXBzIHVzZWQgZm9yIGNv bXB1dGluZyB0b3RhbF90aW1lX2VuYWJsZWQKKwkgKiBhbmQgdG90YWxfdGltZV9ydW5uaW5n IHdoZW4gdGhlIGV2ZW50IGlzIGluIElOQUNUSVZFIG9yCisJICogQUNUSVZFIHN0YXRlLCBt ZWFzdXJlZCBpbiBuYW5vc2Vjb25kcyBmcm9tIGFuIGFyYml0cmFyeSBwb2ludAorCSAqIGlu IHRpbWUuCisJICogZW5hYmxlZDogdGhlIG5vdGlvbmFsIHRpbWUgd2hlbiB0aGUgZXZlbnQg d2FzIGVuYWJsZWQKKwkgKiBydW5uaW5nOiB0aGUgbm90aW9uYWwgdGltZSB3aGVuIHRoZSBl dmVudCB3YXMgc2NoZWR1bGVkIG9uCisJICogc3RvcHBlZDogaW4gSU5BQ1RJVkUgc3RhdGUs IHRoZSBub3Rpb25hbCB0aW1lIHdoZW4gdGhlCisJICogICAgZXZlbnQgd2FzIHNjaGVkdWxl ZCBvZmYuCisJICovCisJdTY0IGVuYWJsZWQ7CisJdTY0IHJ1bm5pbmc7CisJdTY0IHN0b3Bw ZWQ7Cit9OworCiAvKioKICAqIHN0cnVjdCBwZXJmX2V2ZW50IC0gcGVyZm9ybWFuY2UgZXZl bnQga2VybmVsIHJlcHJlc2VudGF0aW9uOgogICovCkBAIC01NzIsNyArNTg4LDIwIEBAIHN0 cnVjdCBwZXJmX2V2ZW50IHsKIAkgKi8KIAlzdHJ1Y3QgbGlzdF9oZWFkCQlncm91cF9lbnRy eTsKIAlzdHJ1Y3QgbGlzdF9oZWFkCQlzaWJsaW5nX2xpc3Q7Ci0KKwkvKgorCSAqIE5vZGUg b24gdGhlIHBpbm5lZCBvciBmbGV4aWJsZSB0cmVlIGxvY2F0ZWQgYXQgdGhlIGV2ZW50IGNv bnRleHQ7CisJICogdGhlIG5vZGUgbWF5IGJlIGVtcHR5IGluIGNhc2UgaXRzIGV2ZW50IGlz IG5vdCBkaXJlY3RseSBhdHRhY2hlZAorCSAqIHRvIHRoZSB0cmVlIGJ1dCB0byBncm91cF9s aXN0IGxpc3Qgb2YgdGhlIGV2ZW50IGRpcmVjdGx5CisJICogYXR0YWNoZWQgdG8gdGhlIHRy ZWU7CisJICovCisJc3RydWN0IHJiX25vZGUJCQlncm91cF9ub2RlOworCS8qCisJICogTGlz dCBrZWVwcyBncm91cHMgYWxsb2NhdGVkIGZvciB0aGUgc2FtZSBjcHU7CisJICogdGhlIGxp c3QgbWF5IGJlIGVtcHR5IGluIGNhc2UgaXRzIGV2ZW50IGlzIG5vdCBkaXJlY3RseQorCSAq IGF0dGFjaGVkIHRvIHRoZSB0cmVlIGJ1dCB0byBncm91cF9saXN0IGxpc3Qgb2YgdGhlIGV2 ZW50IGRpcmVjdGx5CisJICogYXR0YWNoZWQgdG8gdGhlIHRyZWU7CisJICovCisJc3RydWN0 IGxpc3RfaGVhZAkJZ3JvdXBfbGlzdDsKIAkvKgogCSAqIFdlIG5lZWQgc3RvcmFnZSB0byB0 cmFjayB0aGUgZW50cmllcyBpbiBwZXJmX3BtdV9taWdyYXRlX2NvbnRleHQ7IHdlCiAJICog Y2Fubm90IHVzZSB0aGUgZXZlbnRfZW50cnkgYmVjYXVzZSBvZiBSQ1UgYW5kIHdlIHdhbnQg dG8ga2VlcCB0aGUKQEAgLTYxMSwxOSArNjQwLDExIEBAIHN0cnVjdCBwZXJmX2V2ZW50IHsK IAl1NjQJCQkJdG90YWxfdGltZV9ydW5uaW5nOwogCiAJLyoKLQkgKiBUaGVzZSBhcmUgdGlt ZXN0YW1wcyB1c2VkIGZvciBjb21wdXRpbmcgdG90YWxfdGltZV9lbmFibGVkCi0JICogYW5k IHRvdGFsX3RpbWVfcnVubmluZyB3aGVuIHRoZSBldmVudCBpcyBpbiBJTkFDVElWRSBvcgot CSAqIEFDVElWRSBzdGF0ZSwgbWVhc3VyZWQgaW4gbmFub3NlY29uZHMgZnJvbSBhbiBhcmJp dHJhcnkgcG9pbnQKLQkgKiBpbiB0aW1lLgotCSAqIHRzdGFtcF9lbmFibGVkOiB0aGUgbm90 aW9uYWwgdGltZSB3aGVuIHRoZSBldmVudCB3YXMgZW5hYmxlZAotCSAqIHRzdGFtcF9ydW5u aW5nOiB0aGUgbm90aW9uYWwgdGltZSB3aGVuIHRoZSBldmVudCB3YXMgc2NoZWR1bGVkIG9u Ci0JICogdHN0YW1wX3N0b3BwZWQ6IGluIElOQUNUSVZFIHN0YXRlLCB0aGUgbm90aW9uYWwg dGltZSB3aGVuIHRoZQotCSAqCWV2ZW50IHdhcyBzY2hlZHVsZWQgb2ZmLgorCSAqIHRzdGFt cCBwb2ludHMgdG8gdGhlIHRzdGFtcF9kYXRhIG9iamVjdCBiZWxvdyBvciB0byB0aGUgb2Jq ZWN0CisJICogbG9jYXRlZCBhdCB0aGUgZXZlbnQgY29udGV4dDsKIAkgKi8KLQl1NjQJCQkJ dHN0YW1wX2VuYWJsZWQ7Ci0JdTY0CQkJCXRzdGFtcF9ydW5uaW5nOwotCXU2NAkJCQl0c3Rh bXBfc3RvcHBlZDsKLQorCXN0cnVjdCBwZXJmX2V2ZW50X3RzdGFtcAkqdHN0YW1wOworCXN0 cnVjdCBwZXJmX2V2ZW50X3RzdGFtcAl0c3RhbXBfZGF0YTsKIAkvKgogCSAqIHRpbWVzdGFt cCBzaGFkb3dzIHRoZSBhY3R1YWwgY29udGV4dCB0aW1pbmcgYnV0IGl0IGNhbgogCSAqIGJl IHNhZmVseSB1c2VkIGluIE5NSSBpbnRlcnJ1cHQgY29udGV4dC4gSXQgcmVmbGVjdHMgdGhl CkBAIC03NDEsOCArNzYyLDggQEAgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCB7CiAJc3Ry dWN0IG11dGV4CQkJbXV0ZXg7CiAKIAlzdHJ1Y3QgbGlzdF9oZWFkCQlhY3RpdmVfY3R4X2xp c3Q7Ci0Jc3RydWN0IGxpc3RfaGVhZAkJcGlubmVkX2dyb3VwczsKLQlzdHJ1Y3QgbGlzdF9o ZWFkCQlmbGV4aWJsZV9ncm91cHM7CisJc3RydWN0IHJiX3Jvb3QJCQlwaW5uZWRfZ3JvdXBz OworCXN0cnVjdCByYl9yb290CQkJZmxleGlibGVfZ3JvdXBzOwogCXN0cnVjdCBsaXN0X2hl YWQJCWV2ZW50X2xpc3Q7CiAJaW50CQkJCW5yX2V2ZW50czsKIAlpbnQJCQkJbnJfYWN0aXZl OwpAQCAtNzU4LDYgKzc3OSwxMCBAQCBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0IHsKIAkg Ki8KIAl1NjQJCQkJdGltZTsKIAl1NjQJCQkJdGltZXN0YW1wOworCS8qCisJICogQ29udGV4 dCBjYWNoZSBmb3IgZmlsdGVyZWQgb3V0IGV2ZW50czsKKwkgKi8KKwlzdHJ1Y3QgcGVyZl9l dmVudF90c3RhbXAJdHN0YW1wX2RhdGE7CiAKIAkvKgogCSAqIFRoZXNlIGZpZWxkcyBsZXQg dXMgZGV0ZWN0IHdoZW4gdHdvIGNvbnRleHRzIGhhdmUgYm90aApkaWZmIC0tZ2l0IGEva2Vy bmVsL2V2ZW50cy9jb3JlLmMgYi9rZXJuZWwvZXZlbnRzL2NvcmUuYwppbmRleCBiYzYzZjhk Li4yZDAyZjc1IDEwMDY0NAotLS0gYS9rZXJuZWwvZXZlbnRzL2NvcmUuYworKysgYi9rZXJu ZWwvZXZlbnRzL2NvcmUuYwpAQCAtNTU1LDExICs1NTUsMTEgQEAgdm9pZCBwZXJmX3NhbXBs ZV9ldmVudF90b29rKHU2NCBzYW1wbGVfbGVuX25zKQogc3RhdGljIGF0b21pYzY0X3QgcGVy Zl9ldmVudF9pZDsKIAogc3RhdGljIHZvaWQgY3B1X2N0eF9zY2hlZF9vdXQoc3RydWN0IHBl cmZfY3B1X2NvbnRleHQgKmNwdWN0eCwKLQkJCSAgICAgIGVudW0gZXZlbnRfdHlwZV90IGV2 ZW50X3R5cGUpOworCQkJICAgICAgZW51bSBldmVudF90eXBlX3QgZXZlbnRfdHlwZSwgaW50 IG11eCk7CiAKIHN0YXRpYyB2b2lkIGNwdV9jdHhfc2NoZWRfaW4oc3RydWN0IHBlcmZfY3B1 X2NvbnRleHQgKmNwdWN0eCwKIAkJCSAgICAgZW51bSBldmVudF90eXBlX3QgZXZlbnRfdHlw ZSwKLQkJCSAgICAgc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKTsKKwkJCSAgICAgc3RydWN0 IHRhc2tfc3RydWN0ICp0YXNrLCBpbnQgbXV4KTsKIAogc3RhdGljIHZvaWQgdXBkYXRlX2Nv bnRleHRfdGltZShzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgpOwogc3RhdGljIHU2 NCBwZXJmX2V2ZW50X3RpbWUoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KTsKQEAgLTcwMSw2 ICs3MDEsNyBAQCBzdGF0aWMgdm9pZCBwZXJmX2Nncm91cF9zd2l0Y2goc3RydWN0IHRhc2tf c3RydWN0ICp0YXNrLCBpbnQgbW9kZSkKIAlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1 Y3R4OwogCXN0cnVjdCBsaXN0X2hlYWQgKmxpc3Q7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsK KwlpbnQgbXV4ID0gMDsKIAogCS8qCiAJICogRGlzYWJsZSBpbnRlcnJ1cHRzIGFuZCBwcmVl bXB0aW9uIHRvIGF2b2lkIHRoaXMgQ1BVJ3MKQEAgLTcxNiw3ICs3MTcsNyBAQCBzdGF0aWMg dm9pZCBwZXJmX2Nncm91cF9zd2l0Y2goc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLCBpbnQg bW9kZSkKIAkJcGVyZl9wbXVfZGlzYWJsZShjcHVjdHgtPmN0eC5wbXUpOwogCiAJCWlmICht b2RlICYgUEVSRl9DR1JPVVBfU1dPVVQpIHsKLQkJCWNwdV9jdHhfc2NoZWRfb3V0KGNwdWN0 eCwgRVZFTlRfQUxMKTsKKwkJCWNwdV9jdHhfc2NoZWRfb3V0KGNwdWN0eCwgRVZFTlRfQUxM LCBtdXgpOwogCQkJLyoKIAkJCSAqIG11c3Qgbm90IGJlIGRvbmUgYmVmb3JlIGN0eHN3b3V0 IGR1ZQogCQkJICogdG8gZXZlbnRfZmlsdGVyX21hdGNoKCkgaW4gZXZlbnRfc2NoZWRfb3V0 KCkKQEAgLTczNSw3ICs3MzYsNyBAQCBzdGF0aWMgdm9pZCBwZXJmX2Nncm91cF9zd2l0Y2go c3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLCBpbnQgbW9kZSkKIAkJCSAqLwogCQkJY3B1Y3R4 LT5jZ3JwID0gcGVyZl9jZ3JvdXBfZnJvbV90YXNrKHRhc2ssCiAJCQkJCQkJICAgICAmY3B1 Y3R4LT5jdHgpOwotCQkJY3B1X2N0eF9zY2hlZF9pbihjcHVjdHgsIEVWRU5UX0FMTCwgdGFz ayk7CisJCQljcHVfY3R4X3NjaGVkX2luKGNwdWN0eCwgRVZFTlRfQUxMLCB0YXNrLCBtdXgp OwogCQl9CiAJCXBlcmZfcG11X2VuYWJsZShjcHVjdHgtPmN0eC5wbXUpOwogCQlwZXJmX2N0 eF91bmxvY2soY3B1Y3R4LCBjcHVjdHgtPnRhc2tfY3R4KTsKQEAgLTg2NSwxMCArODY2LDEw IEBAIHBlcmZfY2dyb3VwX21hcmtfZW5hYmxlZChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQs CiAKIAlldmVudC0+Y2dycF9kZWZlcl9lbmFibGVkID0gMDsKIAotCWV2ZW50LT50c3RhbXBf ZW5hYmxlZCA9IHRzdGFtcCAtIGV2ZW50LT50b3RhbF90aW1lX2VuYWJsZWQ7CisJZXZlbnQt PnRzdGFtcC0+ZW5hYmxlZCA9IHRzdGFtcCAtIGV2ZW50LT50b3RhbF90aW1lX2VuYWJsZWQ7 CiAJbGlzdF9mb3JfZWFjaF9lbnRyeShzdWIsICZldmVudC0+c2libGluZ19saXN0LCBncm91 cF9lbnRyeSkgewogCQlpZiAoc3ViLT5zdGF0ZSA+PSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNU SVZFKSB7Ci0JCQlzdWItPnRzdGFtcF9lbmFibGVkID0gdHN0YW1wIC0gc3ViLT50b3RhbF90 aW1lX2VuYWJsZWQ7CisJCQlzdWItPnRzdGFtcC0+ZW5hYmxlZCA9IHRzdGFtcCAtIHN1Yi0+ dG90YWxfdGltZV9lbmFibGVkOwogCQkJc3ViLT5jZ3JwX2RlZmVyX2VuYWJsZWQgPSAwOwog CQl9CiAJfQpAQCAtMTM3OCw2ICsxMzc5LDkgQEAgc3RhdGljIHZvaWQgdXBkYXRlX2NvbnRl eHRfdGltZShzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgpCiAKIAljdHgtPnRpbWUg Kz0gbm93IC0gY3R4LT50aW1lc3RhbXA7CiAJY3R4LT50aW1lc3RhbXAgPSBub3c7CisKKwlj dHgtPnRzdGFtcF9kYXRhLnJ1bm5pbmcgKz0gY3R4LT50aW1lIC0gY3R4LT50c3RhbXBfZGF0 YS5zdG9wcGVkOworCWN0eC0+dHN0YW1wX2RhdGEuc3RvcHBlZCA9IGN0eC0+dGltZTsKIH0K IAogc3RhdGljIHU2NCBwZXJmX2V2ZW50X3RpbWUoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50 KQpAQCAtMTQxOSwxNiArMTQyMywxNiBAQCBzdGF0aWMgdm9pZCB1cGRhdGVfZXZlbnRfdGlt ZXMoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQogCWVsc2UgaWYgKGN0eC0+aXNfYWN0aXZl KQogCQlydW5fZW5kID0gY3R4LT50aW1lOwogCWVsc2UKLQkJcnVuX2VuZCA9IGV2ZW50LT50 c3RhbXBfc3RvcHBlZDsKKwkJcnVuX2VuZCA9IGV2ZW50LT50c3RhbXAtPnN0b3BwZWQ7CiAK LQlldmVudC0+dG90YWxfdGltZV9lbmFibGVkID0gcnVuX2VuZCAtIGV2ZW50LT50c3RhbXBf ZW5hYmxlZDsKKwlldmVudC0+dG90YWxfdGltZV9lbmFibGVkID0gcnVuX2VuZCAtIGV2ZW50 LT50c3RhbXAtPmVuYWJsZWQ7CiAKIAlpZiAoZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRf U1RBVEVfSU5BQ1RJVkUpCi0JCXJ1bl9lbmQgPSBldmVudC0+dHN0YW1wX3N0b3BwZWQ7CisJ CXJ1bl9lbmQgPSBldmVudC0+dHN0YW1wLT5zdG9wcGVkOwogCWVsc2UKIAkJcnVuX2VuZCA9 IHBlcmZfZXZlbnRfdGltZShldmVudCk7CiAKLQlldmVudC0+dG90YWxfdGltZV9ydW5uaW5n ID0gcnVuX2VuZCAtIGV2ZW50LT50c3RhbXBfcnVubmluZzsKKwlldmVudC0+dG90YWxfdGlt ZV9ydW5uaW5nID0gcnVuX2VuZCAtIGV2ZW50LT50c3RhbXAtPnJ1bm5pbmc7CiAKIH0KIApA QCAtMTQ1OCw4ICsxNDYyLDEyIEBAIHN0YXRpYyBlbnVtIGV2ZW50X3R5cGVfdCBnZXRfZXZl bnRfdHlwZShzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCiAJcmV0dXJuIGV2ZW50X3R5cGU7 CiB9CiAKLXN0YXRpYyBzdHJ1Y3QgbGlzdF9oZWFkICoKLWN0eF9ncm91cF9saXN0KHN0cnVj dCBwZXJmX2V2ZW50ICpldmVudCwgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQor LyoKKyAqIEV4dHJhY3QgcGlubmVkIG9yIGZsZXhpYmxlIGdyb3VwcyBmcm9tIHRoZSBjb250 ZXh0CisgKiBiYXNlZCBvbiBldmVudCBhdHRycyBiaXRzOworICovCitzdGF0aWMgc3RydWN0 IHJiX3Jvb3QgKgorZ2V0X2V2ZW50X2dyb3VwcyhzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQs IHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCkKIHsKIAlpZiAoZXZlbnQtPmF0dHIu cGlubmVkKQogCQlyZXR1cm4gJmN0eC0+cGlubmVkX2dyb3VwczsKQEAgLTE0NjcsNiArMTQ3 NSwyMDQgQEAgY3R4X2dyb3VwX2xpc3Qoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBzdHJ1 Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgpCiAJCXJldHVybiAmY3R4LT5mbGV4aWJsZV9n cm91cHM7CiB9CiAKK3N0YXRpYyB2b2lkCitwZXJmX2V2ZW50X2dyb3Vwc19pbnNlcnQoc3Ry dWN0IHJiX3Jvb3QgKmdyb3VwcywKKwkJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KTsKKwor c3RhdGljIHZvaWQKK3BlcmZfZXZlbnRfZ3JvdXBzX2RlbGV0ZShzdHJ1Y3QgcmJfcm9vdCAq Z3JvdXBzLAorCQlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpOworCisvKgorICogSGVscGVy IGZ1bmN0aW9uIHRvIGluc2VydCBldmVudCBpbnRvIHRoZSBwaW5uZWQgb3IKKyAqIGZsZXhp YmxlIGdyb3VwczsKKyAqLworc3RhdGljIHZvaWQKK2FkZF9ldmVudF90b19ncm91cHMoc3Ry dWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgp Cit7CisJc3RydWN0IHJiX3Jvb3QgKmdyb3VwczsKKworCWdyb3VwcyA9IGdldF9ldmVudF9n cm91cHMoZXZlbnQsIGN0eCk7CisJcGVyZl9ldmVudF9ncm91cHNfaW5zZXJ0KGdyb3Vwcywg ZXZlbnQpOworfQorCisvKgorICogSGVscGVyIGZ1bmN0aW9uIHRvIGRlbGV0ZSBldmVudCBm cm9tIGl0cyBncm91cHM7CisgKi8KK3N0YXRpYyB2b2lkCitkZWxfZXZlbnRfZnJvbV9ncm91 cHMoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0 ICpjdHgpCit7CisJc3RydWN0IHJiX3Jvb3QgKmdyb3VwczsKKworCWdyb3VwcyA9IGdldF9l dmVudF9ncm91cHMoZXZlbnQsIGN0eCk7CisJcGVyZl9ldmVudF9ncm91cHNfZGVsZXRlKGdy b3VwcywgZXZlbnQpOworfQorCisvKgorICogSW5zZXJ0IGEgZ3JvdXAgaW50byBhIHRyZWUg dXNpbmcgZXZlbnQtPmNwdSBhcyBhIGtleS4gSWYgZXZlbnQtPmNwdSBub2RlCisgKiBpcyBh bHJlYWR5IGF0dGFjaGVkIHRvIHRoZSB0cmVlIHRoZW4gdGhlIGV2ZW50IGlzIGFkZGVkIHRv IHRoZSBhdHRhY2hlZAorICogZ3JvdXAncyBncm91cF9saXN0IGxpc3QuCisgKi8KK3N0YXRp YyB2b2lkCitwZXJmX2V2ZW50X2dyb3Vwc19pbnNlcnQoc3RydWN0IHJiX3Jvb3QgKmdyb3Vw cywgc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQoreworCXN0cnVjdCByYl9ub2RlICoqbm9k ZTsKKwlzdHJ1Y3QgcmJfbm9kZSAqcGFyZW50OworCXN0cnVjdCBwZXJmX2V2ZW50ICpub2Rl X2V2ZW50OworCisJV0FSTl9PTl9PTkNFKCFncm91cHMgfHwgIWV2ZW50KTsKKwlXQVJOX09O X09OQ0UoIWxpc3RfZW1wdHkoJmV2ZW50LT5ncm91cF9lbnRyeSkpOworCisJbm9kZSA9ICZn cm91cHMtPnJiX25vZGU7CisJcGFyZW50ID0gKm5vZGU7CisKKwl3aGlsZSAoKm5vZGUpIHsK KwkJcGFyZW50ID0gKm5vZGU7CisJCW5vZGVfZXZlbnQgPSBjb250YWluZXJfb2YoKm5vZGUs CisJCQkJc3RydWN0IHBlcmZfZXZlbnQsIGdyb3VwX25vZGUpOworCisJCWlmIChldmVudC0+ Y3B1IDwgbm9kZV9ldmVudC0+Y3B1KSB7CisJCQlub2RlID0gJnBhcmVudC0+cmJfbGVmdDsK KwkJfSBlbHNlIGlmIChldmVudC0+Y3B1ID4gbm9kZV9ldmVudC0+Y3B1KSB7CisJCQlub2Rl ID0gJnBhcmVudC0+cmJfcmlnaHQ7CisJCX0gZWxzZSB7CisJCQlsaXN0X2FkZF90YWlsKCZl dmVudC0+Z3JvdXBfZW50cnksCisJCQkJCSZub2RlX2V2ZW50LT5ncm91cF9saXN0KTsKKwkJ CXJldHVybjsKKwkJfQorCX0KKworCWxpc3RfYWRkX3RhaWwoJmV2ZW50LT5ncm91cF9lbnRy eSwgJmV2ZW50LT5ncm91cF9saXN0KTsKKworCXJiX2xpbmtfbm9kZSgmZXZlbnQtPmdyb3Vw X25vZGUsIHBhcmVudCwgbm9kZSk7CisJcmJfaW5zZXJ0X2NvbG9yKCZldmVudC0+Z3JvdXBf bm9kZSwgZ3JvdXBzKTsKK30KKworLyoKKyAqIERlbGV0ZSBhIGdyb3VwIGZyb20gYSB0cmVl LiBJZiB0aGUgZ3JvdXAgaXMgZGlyZWN0bHkgYXR0YWNoZWQgdG8gdGhlIHRyZWUKKyAqIGl0 IGFsc28gZGV0YWNoZXMgYWxsIGdyb3VwcyBvbiB0aGUgZ3JvdXAncyBncm91cF9saXN0IGxp c3QuCisgKi8KK3N0YXRpYyB2b2lkCitwZXJmX2V2ZW50X2dyb3Vwc19kZWxldGUoc3RydWN0 IHJiX3Jvb3QgKmdyb3Vwcywgc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQoreworCXN0cnVj dCBwZXJmX2V2ZW50ICpuZXh0OworCisJV0FSTl9PTl9PTkNFKCFldmVudCk7CisJV0FSTl9P Tl9PTkNFKGxpc3RfZW1wdHkoJmV2ZW50LT5ncm91cF9lbnRyeSkpOworCisJbGlzdF9kZWxf aW5pdCgmZXZlbnQtPmdyb3VwX2VudHJ5KTsKKworCWlmICghUkJfRU1QVFlfTk9ERSgmZXZl bnQtPmdyb3VwX25vZGUpKSB7CisJCVdBUk5fT05fT05DRSghZ3JvdXBzKTsKKwkJaWYgKCFS Ql9FTVBUWV9ST09UKGdyb3VwcykpIHsKKwkJCWlmIChsaXN0X2VtcHR5KCZldmVudC0+Z3Jv dXBfbGlzdCkpIHsKKwkJCQlyYl9lcmFzZSgmZXZlbnQtPmdyb3VwX25vZGUsIGdyb3Vwcyk7 CisJCQl9IGVsc2UgeworCQkJCW5leHQgPSBsaXN0X2ZpcnN0X2VudHJ5KCZldmVudC0+Z3Jv dXBfbGlzdCwKKwkJCQkJCXN0cnVjdCBwZXJmX2V2ZW50LCBncm91cF9lbnRyeSk7CisJCQkJ bGlzdF9yZXBsYWNlX2luaXQoJmV2ZW50LT5ncm91cF9saXN0LAorCQkJCQkJJm5leHQtPmdy b3VwX2xpc3QpOworCQkJCXJiX3JlcGxhY2Vfbm9kZSgmZXZlbnQtPmdyb3VwX25vZGUsCisJ CQkJCQkmbmV4dC0+Z3JvdXBfbm9kZSwgZ3JvdXBzKTsKKworCQkJfQorCQl9CisJCVJCX0NM RUFSX05PREUoJmV2ZW50LT5ncm91cF9ub2RlKTsKKwl9Cit9CisKKy8qCisgKiBGaW5kIGdy b3VwIGxpc3QgYnkgYSBjcHUga2V5IGFuZCByb3RhdGUgaXQuCisgKi8KK3N0YXRpYyB2b2lk CitwZXJmX2V2ZW50X2dyb3Vwc19yb3RhdGUoc3RydWN0IHJiX3Jvb3QgKmdyb3VwcywgaW50 IGNwdSkKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqbm9kZTsKKwlzdHJ1Y3QgcGVyZl9ldmVudCAq bm9kZV9ldmVudDsKKworCVdBUk5fT05fT05DRSghZ3JvdXBzKTsKKworCW5vZGUgPSBncm91 cHMtPnJiX25vZGU7CisKKwl3aGlsZSAobm9kZSkgeworCQlub2RlX2V2ZW50ID0gY29udGFp bmVyX29mKG5vZGUsCisJCQkJc3RydWN0IHBlcmZfZXZlbnQsIGdyb3VwX25vZGUpOworCisJ CWlmIChjcHUgPCBub2RlX2V2ZW50LT5jcHUpIHsKKwkJCW5vZGUgPSBub2RlLT5yYl9sZWZ0 OworCQl9IGVsc2UgaWYgKGNwdSA+IG5vZGVfZXZlbnQtPmNwdSkgeworCQkJbm9kZSA9IG5v ZGUtPnJiX3JpZ2h0OworCQl9IGVsc2UgeworCQkJbGlzdF9yb3RhdGVfbGVmdCgmbm9kZV9l dmVudC0+Z3JvdXBfbGlzdCk7CisJCQlicmVhazsKKwkJfQorCX0KK30KKworLyoKKyAqIEZp bmQgZ3JvdXBfbGlzdCBsaXN0IGJ5IGEgY3B1IGtleSBhbmQgY2FsbCBwcm92aWRlZCBjYWxs YmFjayBmb3IgZXZlcnkKKyAqIGdyb3VwIG9uIHRoZSBsaXN0LgorICovCisKK3R5cGVkZWYg aW50KCpwZXJmX2V2ZW50X2dyb3Vwc19pdGVyYXRlX2YpKHN0cnVjdCBwZXJmX2V2ZW50ICos IHZvaWQgKik7CisKK3N0YXRpYyB2b2lkCitwZXJmX2V2ZW50X2dyb3Vwc19pdGVyYXRlX2Nw dShzdHJ1Y3QgcmJfcm9vdCAqZ3JvdXBzLCBpbnQgY3B1LAorCQlwZXJmX2V2ZW50X2dyb3Vw c19pdGVyYXRlX2YgY2FsbGJhY2ssIHZvaWQgKmRhdGEpCit7CisJc3RydWN0IHJiX25vZGUg Km5vZGU7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCAqbm9kZV9ldmVudDsKKworCVdB Uk5fT05fT05DRSghZ3JvdXBzKTsKKworCW5vZGUgPSBncm91cHMtPnJiX25vZGU7CisKKwl3 aGlsZSAobm9kZSkgeworCQlub2RlX2V2ZW50ID0gY29udGFpbmVyX29mKG5vZGUsCisJCQkJ c3RydWN0IHBlcmZfZXZlbnQsIGdyb3VwX25vZGUpOworCisJCWlmIChjcHUgPCBub2RlX2V2 ZW50LT5jcHUpIHsKKwkJCW5vZGUgPSBub2RlLT5yYl9sZWZ0OworCQl9IGVsc2UgaWYgKGNw dSA+IG5vZGVfZXZlbnQtPmNwdSkgeworCQkJbm9kZSA9IG5vZGUtPnJiX3JpZ2h0OworCQl9 IGVsc2UgeworCQkJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJm5vZGVfZXZlbnQtPmdy b3VwX2xpc3QsCisJCQkJCWdyb3VwX2VudHJ5KQorCQkJCWNhbGxiYWNrKGV2ZW50LCBkYXRh KTsKKwkJCWJyZWFrOworCQl9CisJfQorfQorCisvKgorICogSXRlcmF0ZSBldmVudCBncm91 cHMgYW5kIGNhbGwgcHJvdmlkZWQgY2FsbGJhY2sgZm9yIGV2ZXJ5IGdyb3VwIGluIHRoZSB0 cmVlLgorICogSXRlcmF0aW9uIHN0b3BzIGlmIHRoZSBjYWxsYmFjayByZXR1cm5zIG5vbiB6 ZXJvLgorICovCitzdGF0aWMgaW50CitwZXJmX2V2ZW50X2dyb3Vwc19pdGVyYXRlKHN0cnVj dCByYl9yb290ICpncm91cHMsCisJCXBlcmZfZXZlbnRfZ3JvdXBzX2l0ZXJhdGVfZiBjYWxs YmFjaywgdm9pZCAqZGF0YSkKK3sKKwlpbnQgcmV0ID0gMDsKKwlzdHJ1Y3QgcmJfbm9kZSAq bm9kZTsKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsICpub2RlX2V2ZW50OworCisJV0FS Tl9PTl9PTkNFKCFncm91cHMpOworCisJZm9yIChub2RlID0gcmJfZmlyc3QoZ3JvdXBzKTsg bm9kZTsgbm9kZSA9IHJiX25leHQobm9kZSkpIHsKKwkJbm9kZV9ldmVudCA9IGNvbnRhaW5l cl9vZihub2RlLAlzdHJ1Y3QgcGVyZl9ldmVudCwgZ3JvdXBfbm9kZSk7CisJCWxpc3RfZm9y X2VhY2hfZW50cnkoZXZlbnQsICZub2RlX2V2ZW50LT5ncm91cF9saXN0LAorCQkJCWdyb3Vw X2VudHJ5KSB7CisJCQlXQVJOX09OX09OQ0UoIShldmVudC0+Y3B1ID09IG5vZGVfZXZlbnQt PmNwdSkpOworCQkJcmV0ID0gY2FsbGJhY2soZXZlbnQsIGRhdGEpOworCQkJaWYgKHJldCkg eworCQkJCXJldHVybiByZXQ7CisJCQl9CisJCX0KKwl9CisKKwlyZXR1cm4gcmV0OworfQor CiAvKgogICogQWRkIGEgZXZlbnQgZnJvbSB0aGUgbGlzdHMgZm9yIGl0cyBjb250ZXh0Lgog ICogTXVzdCBiZSBjYWxsZWQgd2l0aCBjdHgtPm11dGV4IGFuZCBjdHgtPmxvY2sgaGVsZC4K QEAgLTE0ODUsMTIgKzE2OTEsOCBAQCBsaXN0X2FkZF9ldmVudChzdHJ1Y3QgcGVyZl9ldmVu dCAqZXZlbnQsIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCkKIAkgKiBwZXJmX2dy b3VwX2RldGFjaCBjYW4sIGF0IGFsbCB0aW1lcywgbG9jYXRlIGFsbCBzaWJsaW5ncy4KIAkg Ki8KIAlpZiAoZXZlbnQtPmdyb3VwX2xlYWRlciA9PSBldmVudCkgewotCQlzdHJ1Y3QgbGlz dF9oZWFkICpsaXN0OwotCiAJCWV2ZW50LT5ncm91cF9jYXBzID0gZXZlbnQtPmV2ZW50X2Nh cHM7Ci0KLQkJbGlzdCA9IGN0eF9ncm91cF9saXN0KGV2ZW50LCBjdHgpOwotCQlsaXN0X2Fk ZF90YWlsKCZldmVudC0+Z3JvdXBfZW50cnksIGxpc3QpOworCQlhZGRfZXZlbnRfdG9fZ3Jv dXBzKGV2ZW50LCBjdHgpOwogCX0KIAogCWxpc3RfdXBkYXRlX2Nncm91cF9ldmVudChldmVu dCwgY3R4LCB0cnVlKTsKQEAgLTE2ODEsNyArMTg4Myw3IEBAIGxpc3RfZGVsX2V2ZW50KHN0 cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4 KQogCWxpc3RfZGVsX3JjdSgmZXZlbnQtPmV2ZW50X2VudHJ5KTsKIAogCWlmIChldmVudC0+ Z3JvdXBfbGVhZGVyID09IGV2ZW50KQotCQlsaXN0X2RlbF9pbml0KCZldmVudC0+Z3JvdXBf ZW50cnkpOworCQlkZWxfZXZlbnRfZnJvbV9ncm91cHMoZXZlbnQsIGN0eCk7CiAKIAl1cGRh dGVfZ3JvdXBfdGltZXMoZXZlbnQpOwogCkBAIC0xNzAxLDcgKzE5MDMsNiBAQCBsaXN0X2Rl bF9ldmVudChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIHN0cnVjdCBwZXJmX2V2ZW50X2Nv bnRleHQgKmN0eCkKIHN0YXRpYyB2b2lkIHBlcmZfZ3JvdXBfZGV0YWNoKHN0cnVjdCBwZXJm X2V2ZW50ICpldmVudCkKIHsKIAlzdHJ1Y3QgcGVyZl9ldmVudCAqc2libGluZywgKnRtcDsK LQlzdHJ1Y3QgbGlzdF9oZWFkICpsaXN0ID0gTlVMTDsKIAogCWxvY2tkZXBfYXNzZXJ0X2hl bGQoJmV2ZW50LT5jdHgtPmxvY2spOwogCkBAIC0xNzIyLDIyICsxOTIzLDIzIEBAIHN0YXRp YyB2b2lkIHBlcmZfZ3JvdXBfZGV0YWNoKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKIAkJ Z290byBvdXQ7CiAJfQogCi0JaWYgKCFsaXN0X2VtcHR5KCZldmVudC0+Z3JvdXBfZW50cnkp KQotCQlsaXN0ID0gJmV2ZW50LT5ncm91cF9lbnRyeTsKLQogCS8qCiAJICogSWYgdGhpcyB3 YXMgYSBncm91cCBldmVudCB3aXRoIHNpYmxpbmcgZXZlbnRzIHRoZW4KIAkgKiB1cGdyYWRl IHRoZSBzaWJsaW5ncyB0byBzaW5nbGV0b24gZXZlbnRzIGJ5IGFkZGluZyB0aGVtCiAJICog dG8gd2hhdGV2ZXIgbGlzdCB3ZSBhcmUgb24uCiAJICovCiAJbGlzdF9mb3JfZWFjaF9lbnRy eV9zYWZlKHNpYmxpbmcsIHRtcCwgJmV2ZW50LT5zaWJsaW5nX2xpc3QsIGdyb3VwX2VudHJ5 KSB7Ci0JCWlmIChsaXN0KQotCQkJbGlzdF9tb3ZlX3RhaWwoJnNpYmxpbmctPmdyb3VwX2Vu dHJ5LCBsaXN0KTsKKwogCQlzaWJsaW5nLT5ncm91cF9sZWFkZXIgPSBzaWJsaW5nOwogCiAJ CS8qIEluaGVyaXQgZ3JvdXAgZmxhZ3MgZnJvbSB0aGUgcHJldmlvdXMgbGVhZGVyICovCiAJ CXNpYmxpbmctPmdyb3VwX2NhcHMgPSBldmVudC0+Z3JvdXBfY2FwczsKIAorCQlpZiAoIWxp c3RfZW1wdHkoJmV2ZW50LT5ncm91cF9lbnRyeSkpIHsKKwkJCWxpc3RfZGVsX2luaXQoJnNp YmxpbmctPmdyb3VwX2VudHJ5KTsKKwkJCWFkZF9ldmVudF90b19ncm91cHMoc2libGluZywg ZXZlbnQtPmN0eCk7CisJCX0KKwogCQlXQVJOX09OX09OQ0Uoc2libGluZy0+Y3R4ICE9IGV2 ZW50LT5jdHgpOwogCX0KIApAQCAtMTgwNiw5ICsyMDA4LDEzIEBAIGV2ZW50X3NjaGVkX291 dChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCiAJICovCiAJaWYgKGV2ZW50LT5zdGF0ZSA9 PSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFICYmCiAJICAgICFldmVudF9maWx0ZXJfbWF0 Y2goZXZlbnQpKSB7Ci0JCWRlbHRhID0gdHN0YW1wIC0gZXZlbnQtPnRzdGFtcF9zdG9wcGVk OwotCQlldmVudC0+dHN0YW1wX3J1bm5pbmcgKz0gZGVsdGE7Ci0JCWV2ZW50LT50c3RhbXBf c3RvcHBlZCA9IHRzdGFtcDsKKwkJZGVsdGEgPSB0c3RhbXAgLSBldmVudC0+dHN0YW1wLT5z dG9wcGVkOworCQlldmVudC0+dHN0YW1wLT5ydW5uaW5nICs9IGRlbHRhOworCQlldmVudC0+ dHN0YW1wLT5zdG9wcGVkID0gdHN0YW1wOworCQlpZiAoZXZlbnQtPnRzdGFtcCAhPSAmZXZl bnQtPnRzdGFtcF9kYXRhKSB7CisJCQlldmVudC0+dHN0YW1wX2RhdGEgPSAqZXZlbnQtPnRz dGFtcDsKKwkJCWV2ZW50LT50c3RhbXAgPSAmZXZlbnQtPnRzdGFtcF9kYXRhOworCQl9CiAJ fQogCiAJaWYgKGV2ZW50LT5zdGF0ZSAhPSBQRVJGX0VWRU5UX1NUQVRFX0FDVElWRSkKQEAg LTE4MTYsNyArMjAyMiw3IEBAIGV2ZW50X3NjaGVkX291dChzdHJ1Y3QgcGVyZl9ldmVudCAq ZXZlbnQsCiAKIAlwZXJmX3BtdV9kaXNhYmxlKGV2ZW50LT5wbXUpOwogCi0JZXZlbnQtPnRz dGFtcF9zdG9wcGVkID0gdHN0YW1wOworCWV2ZW50LT50c3RhbXAtPnN0b3BwZWQgPSB0c3Rh bXA7CiAJZXZlbnQtPnBtdS0+ZGVsKGV2ZW50LCAwKTsKIAlldmVudC0+b25jcHUgPSAtMTsK IAlldmVudC0+c3RhdGUgPSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFOwpAQCAtMTg2MSw2 ICsyMDY3LDIyIEBAIGdyb3VwX3NjaGVkX291dChzdHJ1Y3QgcGVyZl9ldmVudCAqZ3JvdXBf ZXZlbnQsCiAJCWNwdWN0eC0+ZXhjbHVzaXZlID0gMDsKIH0KIAorc3RydWN0IGdyb3VwX3Nj aGVkX3BhcmFtcyB7CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eDsKKwlzdHJ1 Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHg7CisJaW50IGNhbl9hZGRfaHc7Cit9OworCitz dGF0aWMgaW50Citncm91cF9zY2hlZF9vdXRfY2FsbGJhY2soc3RydWN0IHBlcmZfZXZlbnQg KmV2ZW50LCB2b2lkICpkYXRhKQoreworCXN0cnVjdCBncm91cF9zY2hlZF9wYXJhbXMgKnBh cmFtcyA9IGRhdGE7CisKKwlncm91cF9zY2hlZF9vdXQoZXZlbnQsIHBhcmFtcy0+Y3B1Y3R4 LCBwYXJhbXMtPmN0eCk7CisKKwlyZXR1cm4gMDsKK30KKwogI2RlZmluZSBERVRBQ0hfR1JP VVAJMHgwMVVMCiAKIC8qCkBAIC0yMDkxLDcgKzIzMTMsNyBAQCBldmVudF9zY2hlZF9pbihz dHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCiAJCWdvdG8gb3V0OwogCX0KIAotCWV2ZW50LT50 c3RhbXBfcnVubmluZyArPSB0c3RhbXAgLSBldmVudC0+dHN0YW1wX3N0b3BwZWQ7CisJZXZl bnQtPnRzdGFtcC0+cnVubmluZyArPSB0c3RhbXAgLSBldmVudC0+dHN0YW1wLT5zdG9wcGVk OwogCiAJaWYgKCFpc19zb2Z0d2FyZV9ldmVudChldmVudCkpCiAJCWNwdWN0eC0+YWN0aXZl X29uY3B1Kys7CkBAIC0yMTYzLDggKzIzODUsOCBAQCBncm91cF9zY2hlZF9pbihzdHJ1Y3Qg cGVyZl9ldmVudCAqZ3JvdXBfZXZlbnQsCiAJCQlzaW11bGF0ZSA9IHRydWU7CiAKIAkJaWYg KHNpbXVsYXRlKSB7Ci0JCQlldmVudC0+dHN0YW1wX3J1bm5pbmcgKz0gbm93IC0gZXZlbnQt PnRzdGFtcF9zdG9wcGVkOwotCQkJZXZlbnQtPnRzdGFtcF9zdG9wcGVkID0gbm93OworCQkJ ZXZlbnQtPnRzdGFtcC0+cnVubmluZyArPSBub3cgLSBldmVudC0+dHN0YW1wLT5zdG9wcGVk OworCQkJZXZlbnQtPnRzdGFtcC0+c3RvcHBlZCA9IG5vdzsKIAkJfSBlbHNlIHsKIAkJCWV2 ZW50X3NjaGVkX291dChldmVudCwgY3B1Y3R4LCBjdHgpOwogCQl9CkBAIC0yMjE2LDQzICsy NDM4LDQ1IEBAIHN0YXRpYyB2b2lkIGFkZF9ldmVudF90b19jdHgoc3RydWN0IHBlcmZfZXZl bnQgKmV2ZW50LAogCiAJbGlzdF9hZGRfZXZlbnQoZXZlbnQsIGN0eCk7CiAJcGVyZl9ncm91 cF9hdHRhY2goZXZlbnQpOwotCWV2ZW50LT50c3RhbXBfZW5hYmxlZCA9IHRzdGFtcDsKLQll dmVudC0+dHN0YW1wX3J1bm5pbmcgPSB0c3RhbXA7Ci0JZXZlbnQtPnRzdGFtcF9zdG9wcGVk ID0gdHN0YW1wOworCWV2ZW50LT50c3RhbXAtPmVuYWJsZWQgPSB0c3RhbXA7CisJZXZlbnQt PnRzdGFtcC0+cnVubmluZyA9IHRzdGFtcDsKKwlldmVudC0+dHN0YW1wLT5zdG9wcGVkID0g dHN0YW1wOwogfQogCiBzdGF0aWMgdm9pZCBjdHhfc2NoZWRfb3V0KHN0cnVjdCBwZXJmX2V2 ZW50X2NvbnRleHQgKmN0eCwKIAkJCSAgc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0 eCwKLQkJCSAgZW51bSBldmVudF90eXBlX3QgZXZlbnRfdHlwZSk7CisJCQkgIGVudW0gZXZl bnRfdHlwZV90IGV2ZW50X3R5cGUsIGludCBtdXgpOwogc3RhdGljIHZvaWQKIGN0eF9zY2hl ZF9pbihzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsCiAJICAgICBzdHJ1Y3QgcGVy Zl9jcHVfY29udGV4dCAqY3B1Y3R4LAogCSAgICAgZW51bSBldmVudF90eXBlX3QgZXZlbnRf dHlwZSwKLQkgICAgIHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzayk7CisJICAgICBzdHJ1Y3Qg dGFza19zdHJ1Y3QgKnRhc2ssIGludCBtdXgpOwogCiBzdGF0aWMgdm9pZCB0YXNrX2N0eF9z Y2hlZF9vdXQoc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCwKIAkJCSAgICAgICBz dHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsCiAJCQkgICAgICAgZW51bSBldmVudF90 eXBlX3QgZXZlbnRfdHlwZSkKIHsKKwlpbnQgbXV4ID0gMDsKKwogCWlmICghY3B1Y3R4LT50 YXNrX2N0eCkKIAkJcmV0dXJuOwogCiAJaWYgKFdBUk5fT05fT05DRShjdHggIT0gY3B1Y3R4 LT50YXNrX2N0eCkpCiAJCXJldHVybjsKIAotCWN0eF9zY2hlZF9vdXQoY3R4LCBjcHVjdHgs IGV2ZW50X3R5cGUpOworCWN0eF9zY2hlZF9vdXQoY3R4LCBjcHVjdHgsIGV2ZW50X3R5cGUs IG11eCk7CiB9CiAKIHN0YXRpYyB2b2lkIHBlcmZfZXZlbnRfc2NoZWRfaW4oc3RydWN0IHBl cmZfY3B1X2NvbnRleHQgKmNwdWN0eCwKIAkJCQlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0 ICpjdHgsCi0JCQkJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQorCQkJCXN0cnVjdCB0YXNr X3N0cnVjdCAqdGFzaywgaW50IG11eCkKIHsKLQljcHVfY3R4X3NjaGVkX2luKGNwdWN0eCwg RVZFTlRfUElOTkVELCB0YXNrKTsKKwljcHVfY3R4X3NjaGVkX2luKGNwdWN0eCwgRVZFTlRf UElOTkVELCB0YXNrLCBtdXgpOwogCWlmIChjdHgpCi0JCWN0eF9zY2hlZF9pbihjdHgsIGNw dWN0eCwgRVZFTlRfUElOTkVELCB0YXNrKTsKLQljcHVfY3R4X3NjaGVkX2luKGNwdWN0eCwg RVZFTlRfRkxFWElCTEUsIHRhc2spOworCQljdHhfc2NoZWRfaW4oY3R4LCBjcHVjdHgsIEVW RU5UX1BJTk5FRCwgdGFzaywgbXV4KTsKKwljcHVfY3R4X3NjaGVkX2luKGNwdWN0eCwgRVZF TlRfRkxFWElCTEUsIHRhc2ssIG11eCk7CiAJaWYgKGN0eCkKLQkJY3R4X3NjaGVkX2luKGN0 eCwgY3B1Y3R4LCBFVkVOVF9GTEVYSUJMRSwgdGFzayk7CisJCWN0eF9zY2hlZF9pbihjdHgs IGNwdWN0eCwgRVZFTlRfRkxFWElCTEUsIHRhc2ssIG11eCk7CiB9CiAKIC8qCkBAIC0yMjc2 LDYgKzI1MDAsNyBAQCBzdGF0aWMgdm9pZCBjdHhfcmVzY2hlZChzdHJ1Y3QgcGVyZl9jcHVf Y29udGV4dCAqY3B1Y3R4LAogewogCWVudW0gZXZlbnRfdHlwZV90IGN0eF9ldmVudF90eXBl ID0gZXZlbnRfdHlwZSAmIEVWRU5UX0FMTDsKIAlib29sIGNwdV9ldmVudCA9ICEhKGV2ZW50 X3R5cGUgJiBFVkVOVF9DUFUpOworCWludCBtdXggPSAwOwogCiAJLyoKIAkgKiBJZiBwaW5u ZWQgZ3JvdXBzIGFyZSBpbnZvbHZlZCwgZmxleGlibGUgZ3JvdXBzIGFsc28gbmVlZCB0byBi ZQpAQCAtMjI5NiwxMSArMjUyMSwxMSBAQCBzdGF0aWMgdm9pZCBjdHhfcmVzY2hlZChzdHJ1 Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAogCSAqICAtIG90aGVyd2lzZSwgZG8gbm90 aGluZyBtb3JlLgogCSAqLwogCWlmIChjcHVfZXZlbnQpCi0JCWNwdV9jdHhfc2NoZWRfb3V0 KGNwdWN0eCwgY3R4X2V2ZW50X3R5cGUpOworCQljcHVfY3R4X3NjaGVkX291dChjcHVjdHgs IGN0eF9ldmVudF90eXBlLCBtdXgpOwogCWVsc2UgaWYgKGN0eF9ldmVudF90eXBlICYgRVZF TlRfUElOTkVEKQotCQljcHVfY3R4X3NjaGVkX291dChjcHVjdHgsIEVWRU5UX0ZMRVhJQkxF KTsKKwkJY3B1X2N0eF9zY2hlZF9vdXQoY3B1Y3R4LCBFVkVOVF9GTEVYSUJMRSwgbXV4KTsK IAotCXBlcmZfZXZlbnRfc2NoZWRfaW4oY3B1Y3R4LCB0YXNrX2N0eCwgY3VycmVudCk7CisJ cGVyZl9ldmVudF9zY2hlZF9pbihjcHVjdHgsIHRhc2tfY3R4LCBjdXJyZW50LCBtdXgpOwog CXBlcmZfcG11X2VuYWJsZShjcHVjdHgtPmN0eC5wbXUpOwogfQogCkBAIC0yMzE4LDYgKzI1 NDMsNyBAQCBzdGF0aWMgaW50ICBfX3BlcmZfaW5zdGFsbF9pbl9jb250ZXh0KHZvaWQgKmlu Zm8pCiAJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqdGFza19jdHggPSBjcHVjdHgtPnRh c2tfY3R4OwogCWJvb2wgcmVwcm9ncmFtID0gdHJ1ZTsKIAlpbnQgcmV0ID0gMDsKKwlpbnQg bXV4ID0gMDsKIAogCXJhd19zcGluX2xvY2soJmNwdWN0eC0+Y3R4LmxvY2spOwogCWlmIChj dHgtPnRhc2spIHsKQEAgLTIzNDQsNyArMjU3MCw3IEBAIHN0YXRpYyBpbnQgIF9fcGVyZl9p bnN0YWxsX2luX2NvbnRleHQodm9pZCAqaW5mbykKIAl9CiAKIAlpZiAocmVwcm9ncmFtKSB7 Ci0JCWN0eF9zY2hlZF9vdXQoY3R4LCBjcHVjdHgsIEVWRU5UX1RJTUUpOworCQljdHhfc2No ZWRfb3V0KGN0eCwgY3B1Y3R4LCBFVkVOVF9USU1FLCBtdXgpOwogCQlhZGRfZXZlbnRfdG9f Y3R4KGV2ZW50LCBjdHgpOwogCQljdHhfcmVzY2hlZChjcHVjdHgsIHRhc2tfY3R4LCBnZXRf ZXZlbnRfdHlwZShldmVudCkpOwogCX0gZWxzZSB7CkBAIC0yNDYzLDEwICsyNjg5LDEwIEBA IHN0YXRpYyB2b2lkIF9fcGVyZl9ldmVudF9tYXJrX2VuYWJsZWQoc3RydWN0IHBlcmZfZXZl bnQgKmV2ZW50KQogCXU2NCB0c3RhbXAgPSBwZXJmX2V2ZW50X3RpbWUoZXZlbnQpOwogCiAJ ZXZlbnQtPnN0YXRlID0gUEVSRl9FVkVOVF9TVEFURV9JTkFDVElWRTsKLQlldmVudC0+dHN0 YW1wX2VuYWJsZWQgPSB0c3RhbXAgLSBldmVudC0+dG90YWxfdGltZV9lbmFibGVkOworCWV2 ZW50LT50c3RhbXAtPmVuYWJsZWQgPSB0c3RhbXAgLSBldmVudC0+dG90YWxfdGltZV9lbmFi bGVkOwogCWxpc3RfZm9yX2VhY2hfZW50cnkoc3ViLCAmZXZlbnQtPnNpYmxpbmdfbGlzdCwg Z3JvdXBfZW50cnkpIHsKIAkJaWYgKHN1Yi0+c3RhdGUgPj0gUEVSRl9FVkVOVF9TVEFURV9J TkFDVElWRSkKLQkJCXN1Yi0+dHN0YW1wX2VuYWJsZWQgPSB0c3RhbXAgLSBzdWItPnRvdGFs X3RpbWVfZW5hYmxlZDsKKwkJCXN1Yi0+dHN0YW1wLT5lbmFibGVkID0gdHN0YW1wIC0gc3Vi LT50b3RhbF90aW1lX2VuYWJsZWQ7CiAJfQogfQogCkBAIC0yNDgwLDEzICsyNzA2LDE0IEBA IHN0YXRpYyB2b2lkIF9fcGVyZl9ldmVudF9lbmFibGUoc3RydWN0IHBlcmZfZXZlbnQgKmV2 ZW50LAogewogCXN0cnVjdCBwZXJmX2V2ZW50ICpsZWFkZXIgPSBldmVudC0+Z3JvdXBfbGVh ZGVyOwogCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKnRhc2tfY3R4OworCWludCBtdXgg PSAwOwogCiAJaWYgKGV2ZW50LT5zdGF0ZSA+PSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZF IHx8CiAJICAgIGV2ZW50LT5zdGF0ZSA8PSBQRVJGX0VWRU5UX1NUQVRFX0VSUk9SKQogCQly ZXR1cm47CiAKIAlpZiAoY3R4LT5pc19hY3RpdmUpCi0JCWN0eF9zY2hlZF9vdXQoY3R4LCBj cHVjdHgsIEVWRU5UX1RJTUUpOworCQljdHhfc2NoZWRfb3V0KGN0eCwgY3B1Y3R4LCBFVkVO VF9USU1FLCBtdXgpOwogCiAJX19wZXJmX2V2ZW50X21hcmtfZW5hYmxlZChldmVudCk7CiAK QEAgLTI0OTYsNyArMjcyMyw3IEBAIHN0YXRpYyB2b2lkIF9fcGVyZl9ldmVudF9lbmFibGUo c3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LAogCWlmICghZXZlbnRfZmlsdGVyX21hdGNoKGV2 ZW50KSkgewogCQlpZiAoaXNfY2dyb3VwX2V2ZW50KGV2ZW50KSkKIAkJCXBlcmZfY2dyb3Vw X2RlZmVyX2VuYWJsZWQoZXZlbnQpOwotCQljdHhfc2NoZWRfaW4oY3R4LCBjcHVjdHgsIEVW RU5UX1RJTUUsIGN1cnJlbnQpOworCQljdHhfc2NoZWRfaW4oY3R4LCBjcHVjdHgsIEVWRU5U X1RJTUUsIGN1cnJlbnQsIG11eCk7CiAJCXJldHVybjsKIAl9CiAKQEAgLTI1MDUsNyArMjcz Miw3IEBAIHN0YXRpYyB2b2lkIF9fcGVyZl9ldmVudF9lbmFibGUoc3RydWN0IHBlcmZfZXZl bnQgKmV2ZW50LAogCSAqIHRoZW4gZG9uJ3QgcHV0IGl0IG9uIHVubGVzcyB0aGUgZ3JvdXAg aXMgb24uCiAJICovCiAJaWYgKGxlYWRlciAhPSBldmVudCAmJiBsZWFkZXItPnN0YXRlICE9 IFBFUkZfRVZFTlRfU1RBVEVfQUNUSVZFKSB7Ci0JCWN0eF9zY2hlZF9pbihjdHgsIGNwdWN0 eCwgRVZFTlRfVElNRSwgY3VycmVudCk7CisJCWN0eF9zY2hlZF9pbihjdHgsIGNwdWN0eCwg RVZFTlRfVElNRSwgY3VycmVudCwgbXV4KTsKIAkJcmV0dXJuOwogCX0KIApAQCAtMjcwMSwx MCArMjkyOCwxNCBAQCBFWFBPUlRfU1lNQk9MX0dQTChwZXJmX2V2ZW50X3JlZnJlc2gpOwog CiBzdGF0aWMgdm9pZCBjdHhfc2NoZWRfb3V0KHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQg KmN0eCwKIAkJCSAgc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCwKLQkJCSAgZW51 bSBldmVudF90eXBlX3QgZXZlbnRfdHlwZSkKKwkJCSAgZW51bSBldmVudF90eXBlX3QgZXZl bnRfdHlwZSwgaW50IG11eCkKIHsKIAlpbnQgaXNfYWN0aXZlID0gY3R4LT5pc19hY3RpdmU7 Ci0Jc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50OworCXN0cnVjdCBncm91cF9zY2hlZF9wYXJh bXMgcGFyYW1zID0geworCQkJLmNwdWN0eCA9IGNwdWN0eCwKKwkJCS5jdHggPSBjdHgKKwl9 OworCWludCBjcHUgPSBzbXBfcHJvY2Vzc29yX2lkKCk7CiAKIAlsb2NrZGVwX2Fzc2VydF9o ZWxkKCZjdHgtPmxvY2spOwogCkBAIC0yNzUxLDEzICsyOTgyLDI3IEBAIHN0YXRpYyB2b2lk IGN0eF9zY2hlZF9vdXQoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4LAogCiAJcGVy Zl9wbXVfZGlzYWJsZShjdHgtPnBtdSk7CiAJaWYgKGlzX2FjdGl2ZSAmIEVWRU5UX1BJTk5F RCkgewotCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGV2ZW50LCAmY3R4LT5waW5uZWRfZ3JvdXBz LCBncm91cF9lbnRyeSkKLQkJCWdyb3VwX3NjaGVkX291dChldmVudCwgY3B1Y3R4LCBjdHgp OworCQlpZiAobXV4KSB7CisJCQlwZXJmX2V2ZW50X2dyb3Vwc19pdGVyYXRlX2NwdSgmY3R4 LT5waW5uZWRfZ3JvdXBzLCAtMSwKKwkJCQkJZ3JvdXBfc2NoZWRfb3V0X2NhbGxiYWNrLCAm cGFyYW1zKTsKKwkJCXBlcmZfZXZlbnRfZ3JvdXBzX2l0ZXJhdGVfY3B1KCZjdHgtPnBpbm5l ZF9ncm91cHMsIGNwdSwKKwkJCQkJZ3JvdXBfc2NoZWRfb3V0X2NhbGxiYWNrLCAmcGFyYW1z KTsKKwkJfSBlbHNlIHsKKwkJCXBlcmZfZXZlbnRfZ3JvdXBzX2l0ZXJhdGUoJmN0eC0+cGlu bmVkX2dyb3VwcywKKwkJCQkJZ3JvdXBfc2NoZWRfb3V0X2NhbGxiYWNrLCAmcGFyYW1zKTsK KwkJfQogCX0KIAogCWlmIChpc19hY3RpdmUgJiBFVkVOVF9GTEVYSUJMRSkgewotCQlsaXN0 X2Zvcl9lYWNoX2VudHJ5KGV2ZW50LCAmY3R4LT5mbGV4aWJsZV9ncm91cHMsIGdyb3VwX2Vu dHJ5KQotCQkJZ3JvdXBfc2NoZWRfb3V0KGV2ZW50LCBjcHVjdHgsIGN0eCk7CisJCWlmICht dXgpIHsKKwkJCXBlcmZfZXZlbnRfZ3JvdXBzX2l0ZXJhdGVfY3B1KCZjdHgtPmZsZXhpYmxl X2dyb3VwcywgLTEsCisJCQkJCWdyb3VwX3NjaGVkX291dF9jYWxsYmFjaywgJnBhcmFtcyk7 CisJCQlwZXJmX2V2ZW50X2dyb3Vwc19pdGVyYXRlX2NwdSgmY3R4LT5mbGV4aWJsZV9ncm91 cHMsIGNwdSwKKwkJCQkJZ3JvdXBfc2NoZWRfb3V0X2NhbGxiYWNrLCAmcGFyYW1zKTsKKwkJ fSBlbHNlIHsKKwkJCXBlcmZfZXZlbnRfZ3JvdXBzX2l0ZXJhdGUoJmN0eC0+ZmxleGlibGVf Z3JvdXBzLAorCQkJCQlncm91cF9zY2hlZF9vdXRfY2FsbGJhY2ssICZwYXJhbXMpOworCQl9 CiAJfQogCXBlcmZfcG11X2VuYWJsZShjdHgtPnBtdSk7CiB9CkBAIC0zMDQ2LDc4ICszMjkx LDg1IEBAIHZvaWQgX19wZXJmX2V2ZW50X3Rhc2tfc2NoZWRfb3V0KHN0cnVjdCB0YXNrX3N0 cnVjdCAqdGFzaywKICAqIENhbGxlZCB3aXRoIElSUXMgZGlzYWJsZWQKICAqLwogc3RhdGlj IHZvaWQgY3B1X2N0eF9zY2hlZF9vdXQoc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0 eCwKLQkJCSAgICAgIGVudW0gZXZlbnRfdHlwZV90IGV2ZW50X3R5cGUpCisJCQkgICAgICBl bnVtIGV2ZW50X3R5cGVfdCBldmVudF90eXBlLCBpbnQgbXV4KQogewotCWN0eF9zY2hlZF9v dXQoJmNwdWN0eC0+Y3R4LCBjcHVjdHgsIGV2ZW50X3R5cGUpOworCWN0eF9zY2hlZF9vdXQo JmNwdWN0eC0+Y3R4LCBjcHVjdHgsIGV2ZW50X3R5cGUsIG11eCk7CiB9CiAKLXN0YXRpYyB2 b2lkCi1jdHhfcGlubmVkX3NjaGVkX2luKHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0 eCwKLQkJICAgIHN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgpCitzdGF0aWMgaW50 CitjdHhfcGlubmVkX3NjaGVkX2luKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgdm9pZCAq ZGF0YSkKIHsKLQlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CisJc3RydWN0IGdyb3VwX3Nj aGVkX3BhcmFtcyAqcGFyYW1zID0gZGF0YTsKIAotCWxpc3RfZm9yX2VhY2hfZW50cnkoZXZl bnQsICZjdHgtPnBpbm5lZF9ncm91cHMsIGdyb3VwX2VudHJ5KSB7Ci0JCWlmIChldmVudC0+ c3RhdGUgPD0gUEVSRl9FVkVOVF9TVEFURV9PRkYpCi0JCQljb250aW51ZTsKLQkJaWYgKCFl dmVudF9maWx0ZXJfbWF0Y2goZXZlbnQpKQotCQkJY29udGludWU7CisJaWYgKGV2ZW50LT5z dGF0ZSA8PSBQRVJGX0VWRU5UX1NUQVRFX09GRikKKwkJcmV0dXJuIDA7CisJaWYgKCFldmVu dF9maWx0ZXJfbWF0Y2goZXZlbnQpKSB7CisJCWlmIChldmVudC0+dHN0YW1wICE9ICZwYXJh bXMtPmN0eC0+dHN0YW1wX2RhdGEpCisJCQlldmVudC0+dHN0YW1wID0gJnBhcmFtcy0+Y3R4 LT50c3RhbXBfZGF0YTsKKwkJcmV0dXJuIDA7CisJfQogCi0JCS8qIG1heSBuZWVkIHRvIHJl c2V0IHRzdGFtcF9lbmFibGVkICovCi0JCWlmIChpc19jZ3JvdXBfZXZlbnQoZXZlbnQpKQot CQkJcGVyZl9jZ3JvdXBfbWFya19lbmFibGVkKGV2ZW50LCBjdHgpOworCS8qIG1heSBuZWVk IHRvIHJlc2V0IHRzdGFtcF9lbmFibGVkICovCisJaWYgKGlzX2Nncm91cF9ldmVudChldmVu dCkpCisJCXBlcmZfY2dyb3VwX21hcmtfZW5hYmxlZChldmVudCwgcGFyYW1zLT5jdHgpOwog Ci0JCWlmIChncm91cF9jYW5fZ29fb24oZXZlbnQsIGNwdWN0eCwgMSkpCi0JCQlncm91cF9z Y2hlZF9pbihldmVudCwgY3B1Y3R4LCBjdHgpOworCWlmIChncm91cF9jYW5fZ29fb24oZXZl bnQsIHBhcmFtcy0+Y3B1Y3R4LCAxKSkKKwkJZ3JvdXBfc2NoZWRfaW4oZXZlbnQsIHBhcmFt cy0+Y3B1Y3R4LCBwYXJhbXMtPmN0eCk7CiAKLQkJLyoKLQkJICogSWYgdGhpcyBwaW5uZWQg Z3JvdXAgaGFzbid0IGJlZW4gc2NoZWR1bGVkLAotCQkgKiBwdXQgaXQgaW4gZXJyb3Igc3Rh dGUuCi0JCSAqLwotCQlpZiAoZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRfU1RBVEVfSU5B Q1RJVkUpIHsKLQkJCXVwZGF0ZV9ncm91cF90aW1lcyhldmVudCk7Ci0JCQlldmVudC0+c3Rh dGUgPSBQRVJGX0VWRU5UX1NUQVRFX0VSUk9SOwotCQl9CisJLyoKKwkgKiBJZiB0aGlzIHBp bm5lZCBncm91cCBoYXNuJ3QgYmVlbiBzY2hlZHVsZWQsCisJICogcHV0IGl0IGluIGVycm9y IHN0YXRlLgorCSAqLworCWlmIChldmVudC0+c3RhdGUgPT0gUEVSRl9FVkVOVF9TVEFURV9J TkFDVElWRSkgeworCQl1cGRhdGVfZ3JvdXBfdGltZXMoZXZlbnQpOworCQlldmVudC0+c3Rh dGUgPSBQRVJGX0VWRU5UX1NUQVRFX0VSUk9SOwogCX0KKworCXJldHVybiAwOwogfQogCi1z dGF0aWMgdm9pZAotY3R4X2ZsZXhpYmxlX3NjaGVkX2luKHN0cnVjdCBwZXJmX2V2ZW50X2Nv bnRleHQgKmN0eCwKLQkJICAgICAgc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCkK K3N0YXRpYyBpbnQKK2N0eF9mbGV4aWJsZV9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9ldmVudCAq ZXZlbnQsIHZvaWQgKmRhdGEpCiB7Ci0Jc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50OwotCWlu dCBjYW5fYWRkX2h3ID0gMTsKKwlzdHJ1Y3QgZ3JvdXBfc2NoZWRfcGFyYW1zICpwYXJhbXMg PSBkYXRhOwogCi0JbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmN0eC0+ZmxleGlibGVf Z3JvdXBzLCBncm91cF9lbnRyeSkgewotCQkvKiBJZ25vcmUgZXZlbnRzIGluIE9GRiBvciBF UlJPUiBzdGF0ZSAqLwotCQlpZiAoZXZlbnQtPnN0YXRlIDw9IFBFUkZfRVZFTlRfU1RBVEVf T0ZGKQotCQkJY29udGludWU7Ci0JCS8qCi0JCSAqIExpc3RlbiB0byB0aGUgJ2NwdScgc2No ZWR1bGluZyBmaWx0ZXIgY29uc3RyYWludAotCQkgKiBvZiBldmVudHM6Ci0JCSAqLwotCQlp ZiAoIWV2ZW50X2ZpbHRlcl9tYXRjaChldmVudCkpCi0JCQljb250aW51ZTsKKwkvKiBJZ25v cmUgZXZlbnRzIGluIE9GRiBvciBFUlJPUiBzdGF0ZSAqLworCWlmIChldmVudC0+c3RhdGUg PD0gUEVSRl9FVkVOVF9TVEFURV9PRkYpCisJCXJldHVybiAwOworCS8qCisJICogTGlzdGVu IHRvIHRoZSAnY3B1JyBzY2hlZHVsaW5nIGZpbHRlciBjb25zdHJhaW50CisJICogb2YgZXZl bnRzOgorCSAqLworCWlmICghZXZlbnRfZmlsdGVyX21hdGNoKGV2ZW50KSkgeworCQlpZiAo ZXZlbnQtPnRzdGFtcCAhPSAmcGFyYW1zLT5jdHgtPnRzdGFtcF9kYXRhKQorCQkJZXZlbnQt PnRzdGFtcCA9ICZwYXJhbXMtPmN0eC0+dHN0YW1wX2RhdGE7CisJCXJldHVybiAwOworCX0K IAotCQkvKiBtYXkgbmVlZCB0byByZXNldCB0c3RhbXBfZW5hYmxlZCAqLwotCQlpZiAoaXNf Y2dyb3VwX2V2ZW50KGV2ZW50KSkKLQkJCXBlcmZfY2dyb3VwX21hcmtfZW5hYmxlZChldmVu dCwgY3R4KTsKKwkvKiBtYXkgbmVlZCB0byByZXNldCB0c3RhbXBfZW5hYmxlZCAqLworCWlm IChpc19jZ3JvdXBfZXZlbnQoZXZlbnQpKQorCQlwZXJmX2Nncm91cF9tYXJrX2VuYWJsZWQo ZXZlbnQsIHBhcmFtcy0+Y3R4KTsKIAotCQlpZiAoZ3JvdXBfY2FuX2dvX29uKGV2ZW50LCBj cHVjdHgsIGNhbl9hZGRfaHcpKSB7Ci0JCQlpZiAoZ3JvdXBfc2NoZWRfaW4oZXZlbnQsIGNw dWN0eCwgY3R4KSkKLQkJCQljYW5fYWRkX2h3ID0gMDsKLQkJfQorCWlmIChncm91cF9jYW5f Z29fb24oZXZlbnQsIHBhcmFtcy0+Y3B1Y3R4LCBwYXJhbXMtPmNhbl9hZGRfaHcpKSB7CisJ CWlmIChncm91cF9zY2hlZF9pbihldmVudCwgcGFyYW1zLT5jcHVjdHgsIHBhcmFtcy0+Y3R4 KSkKKwkJCXBhcmFtcy0+Y2FuX2FkZF9odyA9IDA7CiAJfQorCisJcmV0dXJuIDA7CiB9CiAK IHN0YXRpYyB2b2lkCiBjdHhfc2NoZWRfaW4oc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAq Y3R4LAogCSAgICAgc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCwKIAkgICAgIGVu dW0gZXZlbnRfdHlwZV90IGV2ZW50X3R5cGUsCi0JICAgICBzdHJ1Y3QgdGFza19zdHJ1Y3Qg KnRhc2spCisJICAgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2ssIGludCBtdXgpCiB7CiAJ aW50IGlzX2FjdGl2ZSA9IGN0eC0+aXNfYWN0aXZlOwotCXU2NCBub3c7CisJc3RydWN0IGdy b3VwX3NjaGVkX3BhcmFtcyBwYXJhbXMgPSB7CisJCQkuY3B1Y3R4ID0gY3B1Y3R4LAorCQkJ LmN0eCA9IGN0eAorCX07CisJaW50IGNwdSA9IHNtcF9wcm9jZXNzb3JfaWQoKTsKIAogCWxv Y2tkZXBfYXNzZXJ0X2hlbGQoJmN0eC0+bG9jayk7CiAKQEAgLTMxMzYsNyArMzM4OCw3IEBA IGN0eF9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsCiAKIAlpZiAo aXNfYWN0aXZlICYgRVZFTlRfVElNRSkgewogCQkvKiBzdGFydCBjdHggdGltZSAqLwotCQlu b3cgPSBwZXJmX2Nsb2NrKCk7CisJCXU2NCBub3cgPSBwZXJmX2Nsb2NrKCk7CiAJCWN0eC0+ dGltZXN0YW1wID0gbm93OwogCQlwZXJmX2Nncm91cF9zZXRfdGltZXN0YW1wKHRhc2ssIGN0 eCk7CiAJfQpAQCAtMzE0NSwyNyArMzM5Nyw1NiBAQCBjdHhfc2NoZWRfaW4oc3RydWN0IHBl cmZfZXZlbnRfY29udGV4dCAqY3R4LAogCSAqIEZpcnN0IGdvIHRocm91Z2ggdGhlIGxpc3Qg YW5kIHB1dCBvbiBhbnkgcGlubmVkIGdyb3VwcwogCSAqIGluIG9yZGVyIHRvIGdpdmUgdGhl bSB0aGUgYmVzdCBjaGFuY2Ugb2YgZ29pbmcgb24uCiAJICovCi0JaWYgKGlzX2FjdGl2ZSAm IEVWRU5UX1BJTk5FRCkKLQkJY3R4X3Bpbm5lZF9zY2hlZF9pbihjdHgsIGNwdWN0eCk7CisK KwlpZiAoaXNfYWN0aXZlICYgRVZFTlRfUElOTkVEKSB7CisJCWlmIChtdXgpIHsKKwkJCXBl cmZfZXZlbnRfZ3JvdXBzX2l0ZXJhdGVfY3B1KCZjdHgtPnBpbm5lZF9ncm91cHMsCisJCQkJ CS0xLCBjdHhfcGlubmVkX3NjaGVkX2luLAorCQkJCQkmcGFyYW1zKTsKKwkJCXBlcmZfZXZl bnRfZ3JvdXBzX2l0ZXJhdGVfY3B1KCZjdHgtPnBpbm5lZF9ncm91cHMsCisJCQkJCWNwdSwg Y3R4X3Bpbm5lZF9zY2hlZF9pbiwKKwkJCQkJJnBhcmFtcyk7CisJCX0gZWxzZSB7CisJCQlw ZXJmX2V2ZW50X2dyb3Vwc19pdGVyYXRlKCZjdHgtPnBpbm5lZF9ncm91cHMsCisJCQkJCWN0 eF9waW5uZWRfc2NoZWRfaW4sCisJCQkJCSZwYXJhbXMpOworCQl9CisJfQogCiAJLyogVGhl biB3YWxrIHRocm91Z2ggdGhlIGxvd2VyIHByaW8gZmxleGlibGUgZ3JvdXBzICovCi0JaWYg KGlzX2FjdGl2ZSAmIEVWRU5UX0ZMRVhJQkxFKQotCQljdHhfZmxleGlibGVfc2NoZWRfaW4o Y3R4LCBjcHVjdHgpOworCWlmIChpc19hY3RpdmUgJiBFVkVOVF9GTEVYSUJMRSkgeworCQlp ZiAobXV4KSB7CisJCQlwYXJhbXMuY2FuX2FkZF9odyA9IDE7CisJCQlwZXJmX2V2ZW50X2dy b3Vwc19pdGVyYXRlX2NwdSgmY3R4LT5mbGV4aWJsZV9ncm91cHMsCisJCQkJCS0xLCBjdHhf ZmxleGlibGVfc2NoZWRfaW4sCisJCQkJCSZwYXJhbXMpOworCQkJcGFyYW1zLmNhbl9hZGRf aHcgPSAxOworCQkJcGVyZl9ldmVudF9ncm91cHNfaXRlcmF0ZV9jcHUoJmN0eC0+ZmxleGli bGVfZ3JvdXBzLAorCQkJCQljcHUsIGN0eF9mbGV4aWJsZV9zY2hlZF9pbiwKKwkJCQkJJnBh cmFtcyk7CisJCX0gZWxzZSB7CisJCQlwYXJhbXMuY2FuX2FkZF9odyA9IDE7CisJCQlwZXJm X2V2ZW50X2dyb3Vwc19pdGVyYXRlKCZjdHgtPmZsZXhpYmxlX2dyb3VwcywKKwkJCQkJY3R4 X2ZsZXhpYmxlX3NjaGVkX2luLAorCQkJCQkmcGFyYW1zKTsKKwkJfQorCX0KIH0KIAogc3Rh dGljIHZvaWQgY3B1X2N0eF9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1 Y3R4LAogCQkJICAgICBlbnVtIGV2ZW50X3R5cGVfdCBldmVudF90eXBlLAotCQkJICAgICBz dHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spCisJCQkgICAgIHN0cnVjdCB0YXNrX3N0cnVjdCAq dGFzaywgaW50IG11eCkKIHsKIAlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHggPSAm Y3B1Y3R4LT5jdHg7CiAKLQljdHhfc2NoZWRfaW4oY3R4LCBjcHVjdHgsIGV2ZW50X3R5cGUs IHRhc2spOworCWN0eF9zY2hlZF9pbihjdHgsIGNwdWN0eCwgZXZlbnRfdHlwZSwgdGFzaywg bXV4KTsKIH0KIAogc3RhdGljIHZvaWQgcGVyZl9ldmVudF9jb250ZXh0X3NjaGVkX2luKHN0 cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCwKIAkJCQkJc3RydWN0IHRhc2tfc3RydWN0 ICp0YXNrKQogewogCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHg7CisJaW50IG11 eCA9IDA7CiAKIAljcHVjdHggPSBfX2dldF9jcHVfY29udGV4dChjdHgpOwogCWlmIChjcHVj dHgtPnRhc2tfY3R4ID09IGN0eCkKQEAgLTMxODEsOSArMzQ2Miw5IEBAIHN0YXRpYyB2b2lk IHBlcmZfZXZlbnRfY29udGV4dF9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0 ICpjdHgsCiAJICogSG93ZXZlciwgaWYgdGFzaydzIGN0eCBpcyBub3QgY2FycnlpbmcgYW55 IHBpbm5lZAogCSAqIGV2ZW50cywgbm8gbmVlZCB0byBmbGlwIHRoZSBjcHVjdHgncyBldmVu dHMgYXJvdW5kLgogCSAqLwotCWlmICghbGlzdF9lbXB0eSgmY3R4LT5waW5uZWRfZ3JvdXBz KSkKLQkJY3B1X2N0eF9zY2hlZF9vdXQoY3B1Y3R4LCBFVkVOVF9GTEVYSUJMRSk7Ci0JcGVy Zl9ldmVudF9zY2hlZF9pbihjcHVjdHgsIGN0eCwgdGFzayk7CisJaWYgKCFSQl9FTVBUWV9S T09UKCZjdHgtPnBpbm5lZF9ncm91cHMpKQorCQljcHVfY3R4X3NjaGVkX291dChjcHVjdHgs IEVWRU5UX0ZMRVhJQkxFLCBtdXgpOworCXBlcmZfZXZlbnRfc2NoZWRfaW4oY3B1Y3R4LCBj dHgsIHRhc2ssIG11eCk7CiAJcGVyZl9wbXVfZW5hYmxlKGN0eC0+cG11KTsKIAlwZXJmX2N0 eF91bmxvY2soY3B1Y3R4LCBjdHgpOwogfQpAQCAtMzQxNiwxNCArMzY5NywxOSBAQCBzdGF0 aWMgdm9pZCByb3RhdGVfY3R4KHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCkKIAkg KiBSb3RhdGUgdGhlIGZpcnN0IGVudHJ5IGxhc3Qgb2Ygbm9uLXBpbm5lZCBncm91cHMuIFJv dGF0aW9uIG1pZ2h0IGJlCiAJICogZGlzYWJsZWQgYnkgdGhlIGluaGVyaXRhbmNlIGNvZGUu CiAJICovCi0JaWYgKCFjdHgtPnJvdGF0ZV9kaXNhYmxlKQotCQlsaXN0X3JvdGF0ZV9sZWZ0 KCZjdHgtPmZsZXhpYmxlX2dyb3Vwcyk7CisJaWYgKCFjdHgtPnJvdGF0ZV9kaXNhYmxlKSB7 CisJCWludCBjcHUgPSBzbXBfcHJvY2Vzc29yX2lkKCk7CisKKwkJcGVyZl9ldmVudF9ncm91 cHNfcm90YXRlKCZjdHgtPmZsZXhpYmxlX2dyb3VwcywgLTEpOworCQlwZXJmX2V2ZW50X2dy b3Vwc19yb3RhdGUoJmN0eC0+ZmxleGlibGVfZ3JvdXBzLCBjcHUpOworCX0KIH0KIAogc3Rh dGljIGludCBwZXJmX3JvdGF0ZV9jb250ZXh0KHN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpj cHVjdHgpCiB7CiAJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4ID0gTlVMTDsKIAlp bnQgcm90YXRlID0gMDsKKwlpbnQgbXV4ID0gMTsKIAogCWlmIChjcHVjdHgtPmN0eC5ucl9l dmVudHMpIHsKIAkJaWYgKGNwdWN0eC0+Y3R4Lm5yX2V2ZW50cyAhPSBjcHVjdHgtPmN0eC5u cl9hY3RpdmUpCkBAIC0zNDQyLDE1ICszNzI4LDE1IEBAIHN0YXRpYyBpbnQgcGVyZl9yb3Rh dGVfY29udGV4dChzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4KQogCXBlcmZfY3R4 X2xvY2soY3B1Y3R4LCBjcHVjdHgtPnRhc2tfY3R4KTsKIAlwZXJmX3BtdV9kaXNhYmxlKGNw dWN0eC0+Y3R4LnBtdSk7CiAKLQljcHVfY3R4X3NjaGVkX291dChjcHVjdHgsIEVWRU5UX0ZM RVhJQkxFKTsKKwljcHVfY3R4X3NjaGVkX291dChjcHVjdHgsIEVWRU5UX0ZMRVhJQkxFLCBt dXgpOwogCWlmIChjdHgpCi0JCWN0eF9zY2hlZF9vdXQoY3R4LCBjcHVjdHgsIEVWRU5UX0ZM RVhJQkxFKTsKKwkJY3R4X3NjaGVkX291dChjdHgsIGNwdWN0eCwgRVZFTlRfRkxFWElCTEUs IG11eCk7CiAKIAlyb3RhdGVfY3R4KCZjcHVjdHgtPmN0eCk7CiAJaWYgKGN0eCkKIAkJcm90 YXRlX2N0eChjdHgpOwogCi0JcGVyZl9ldmVudF9zY2hlZF9pbihjcHVjdHgsIGN0eCwgY3Vy cmVudCk7CisJcGVyZl9ldmVudF9zY2hlZF9pbihjcHVjdHgsIGN0eCwgY3VycmVudCwgbXV4 KTsKIAogCXBlcmZfcG11X2VuYWJsZShjcHVjdHgtPmN0eC5wbXUpOwogCXBlcmZfY3R4X3Vu bG9jayhjcHVjdHgsIGNwdWN0eC0+dGFza19jdHgpOwpAQCAtMzUwMiw2ICszNzg4LDcgQEAg c3RhdGljIHZvaWQgcGVyZl9ldmVudF9lbmFibGVfb25fZXhlYyhpbnQgY3R4bikKIAlzdHJ1 Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAlpbnQgZW5h YmxlZCA9IDA7CisJaW50IG11eCA9IDA7CiAKIAlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CiAJ Y3R4ID0gY3VycmVudC0+cGVyZl9ldmVudF9jdHhwW2N0eG5dOwpAQCAtMzUxMCw3ICszNzk3 LDcgQEAgc3RhdGljIHZvaWQgcGVyZl9ldmVudF9lbmFibGVfb25fZXhlYyhpbnQgY3R4bikK IAogCWNwdWN0eCA9IF9fZ2V0X2NwdV9jb250ZXh0KGN0eCk7CiAJcGVyZl9jdHhfbG9jayhj cHVjdHgsIGN0eCk7Ci0JY3R4X3NjaGVkX291dChjdHgsIGNwdWN0eCwgRVZFTlRfVElNRSk7 CisJY3R4X3NjaGVkX291dChjdHgsIGNwdWN0eCwgRVZFTlRfVElNRSwgbXV4KTsKIAlsaXN0 X2Zvcl9lYWNoX2VudHJ5KGV2ZW50LCAmY3R4LT5ldmVudF9saXN0LCBldmVudF9lbnRyeSkg ewogCQllbmFibGVkIHw9IGV2ZW50X2VuYWJsZV9vbl9leGVjKGV2ZW50LCBjdHgpOwogCQll dmVudF90eXBlIHw9IGdldF9ldmVudF90eXBlKGV2ZW50KTsKQEAgLTM1MjMsNyArMzgxMCw3 IEBAIHN0YXRpYyB2b2lkIHBlcmZfZXZlbnRfZW5hYmxlX29uX2V4ZWMoaW50IGN0eG4pCiAJ CWNsb25lX2N0eCA9IHVuY2xvbmVfY3R4KGN0eCk7CiAJCWN0eF9yZXNjaGVkKGNwdWN0eCwg Y3R4LCBldmVudF90eXBlKTsKIAl9IGVsc2UgewotCQljdHhfc2NoZWRfaW4oY3R4LCBjcHVj dHgsIEVWRU5UX1RJTUUsIGN1cnJlbnQpOworCQljdHhfc2NoZWRfaW4oY3R4LCBjcHVjdHgs IEVWRU5UX1RJTUUsIGN1cnJlbnQsIG11eCk7CiAJfQogCXBlcmZfY3R4X3VubG9jayhjcHVj dHgsIGN0eCk7CiAKQEAgLTM3NDMsOCArNDAzMCw4IEBAIHN0YXRpYyB2b2lkIF9fcGVyZl9l dmVudF9pbml0X2NvbnRleHQoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQogCXJh d19zcGluX2xvY2tfaW5pdCgmY3R4LT5sb2NrKTsKIAltdXRleF9pbml0KCZjdHgtPm11dGV4 KTsKIAlJTklUX0xJU1RfSEVBRCgmY3R4LT5hY3RpdmVfY3R4X2xpc3QpOwotCUlOSVRfTElT VF9IRUFEKCZjdHgtPnBpbm5lZF9ncm91cHMpOwotCUlOSVRfTElTVF9IRUFEKCZjdHgtPmZs ZXhpYmxlX2dyb3Vwcyk7CisJY3R4LT5waW5uZWRfZ3JvdXBzID0gUkJfUk9PVDsKKwljdHgt PmZsZXhpYmxlX2dyb3VwcyA9IFJCX1JPT1Q7CiAJSU5JVF9MSVNUX0hFQUQoJmN0eC0+ZXZl bnRfbGlzdCk7CiAJYXRvbWljX3NldCgmY3R4LT5yZWZjb3VudCwgMSk7CiB9CkBAIC00ODQz LDggKzUxMzAsOCBAQCBzdGF0aWMgdm9pZCBjYWxjX3RpbWVyX3ZhbHVlcyhzdHJ1Y3QgcGVy Zl9ldmVudCAqZXZlbnQsCiAKIAkqbm93ID0gcGVyZl9jbG9jaygpOwogCWN0eF90aW1lID0g ZXZlbnQtPnNoYWRvd19jdHhfdGltZSArICpub3c7Ci0JKmVuYWJsZWQgPSBjdHhfdGltZSAt IGV2ZW50LT50c3RhbXBfZW5hYmxlZDsKLQkqcnVubmluZyA9IGN0eF90aW1lIC0gZXZlbnQt PnRzdGFtcF9ydW5uaW5nOworCSplbmFibGVkID0gY3R4X3RpbWUgLSBldmVudC0+dHN0YW1w LT5lbmFibGVkOworCSpydW5uaW5nID0gY3R4X3RpbWUgLSBldmVudC0+dHN0YW1wLT5ydW5u aW5nOwogfQogCiBzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X2luaXRfdXNlcnBhZ2Uoc3RydWN0 IHBlcmZfZXZlbnQgKmV2ZW50KQpAQCAtOTM3OSw2ICs5NjY2LDggQEAgcGVyZl9ldmVudF9h bGxvYyhzdHJ1Y3QgcGVyZl9ldmVudF9hdHRyICphdHRyLCBpbnQgY3B1LAogCUlOSVRfTElT VF9IRUFEKCZldmVudC0+Z3JvdXBfZW50cnkpOwogCUlOSVRfTElTVF9IRUFEKCZldmVudC0+ ZXZlbnRfZW50cnkpOwogCUlOSVRfTElTVF9IRUFEKCZldmVudC0+c2libGluZ19saXN0KTsK KwlSQl9DTEVBUl9OT0RFKCZldmVudC0+Z3JvdXBfbm9kZSk7CisJSU5JVF9MSVNUX0hFQUQo JmV2ZW50LT5ncm91cF9saXN0KTsKIAlJTklUX0xJU1RfSEVBRCgmZXZlbnQtPnJiX2VudHJ5 KTsKIAlJTklUX0xJU1RfSEVBRCgmZXZlbnQtPmFjdGl2ZV9lbnRyeSk7CiAJSU5JVF9MSVNU X0hFQUQoJmV2ZW50LT5hZGRyX2ZpbHRlcnMubGlzdCk7CkBAIC05MzkyLDYgKzk2ODEsNyBA QCBwZXJmX2V2ZW50X2FsbG9jKHN0cnVjdCBwZXJmX2V2ZW50X2F0dHIgKmF0dHIsIGludCBj cHUsCiAJcmF3X3NwaW5fbG9ja19pbml0KCZldmVudC0+YWRkcl9maWx0ZXJzLmxvY2spOwog CiAJYXRvbWljX2xvbmdfc2V0KCZldmVudC0+cmVmY291bnQsIDEpOworCWV2ZW50LT50c3Rh bXAJCT0gJmV2ZW50LT50c3RhbXBfZGF0YTsKIAlldmVudC0+Y3B1CQk9IGNwdTsKIAlldmVu dC0+YXR0cgkJPSAqYXR0cjsKIAlldmVudC0+Z3JvdXBfbGVhZGVyCT0gZ3JvdXBfbGVhZGVy OwpAQCAtMTA3NjcsNiArMTEwNTcsMTQgQEAgc3RhdGljIGludCBpbmhlcml0X2dyb3VwKHN0 cnVjdCBwZXJmX2V2ZW50ICpwYXJlbnRfZXZlbnQsCiAJcmV0dXJuIDA7CiB9CiAKK3N0cnVj dCBpbmhlcml0X3Rhc2tfZ3JvdXBfcGFyYW1zIHsKKwlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnBh cmVudDsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpwYXJlbnRfY3R4OworCXN0cnVj dCB0YXNrX3N0cnVjdCAqY2hpbGQ7CisJaW50IGN0eG47CisJaW50IGluaGVyaXRlZF9hbGw7 Cit9OworCiAvKgogICogQ3JlYXRlcyB0aGUgY2hpbGQgdGFzayBjb250ZXh0IGFuZCB0cmll cyB0byBpbmhlcml0IHRoZSBldmVudC1ncm91cC4KICAqCkBAIC0xMDc3OSwyMCArMTEwNzcs MTggQEAgc3RhdGljIGludCBpbmhlcml0X2dyb3VwKHN0cnVjdCBwZXJmX2V2ZW50ICpwYXJl bnRfZXZlbnQsCiAgKiAgLSA8MCBvbiBlcnJvcgogICovCiBzdGF0aWMgaW50Ci1pbmhlcml0 X3Rhc2tfZ3JvdXAoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBzdHJ1Y3QgdGFza19zdHJ1 Y3QgKnBhcmVudCwKLQkJICAgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqcGFyZW50X2N0 eCwKLQkJICAgc3RydWN0IHRhc2tfc3RydWN0ICpjaGlsZCwgaW50IGN0eG4sCi0JCSAgIGlu dCAqaW5oZXJpdGVkX2FsbCkKK2luaGVyaXRfdGFza19ncm91cChzdHJ1Y3QgcGVyZl9ldmVu dCAqZXZlbnQsIHZvaWQgKmRhdGEpCiB7CiAJaW50IHJldDsKIAlzdHJ1Y3QgcGVyZl9ldmVu dF9jb250ZXh0ICpjaGlsZF9jdHg7CisJc3RydWN0IGluaGVyaXRfdGFza19ncm91cF9wYXJh bXMgKnBhcmFtcyA9IGRhdGE7CiAKIAlpZiAoIWV2ZW50LT5hdHRyLmluaGVyaXQpIHsKLQkJ KmluaGVyaXRlZF9hbGwgPSAwOworCQlwYXJhbXMtPmluaGVyaXRlZF9hbGwgPSAwOwogCQly ZXR1cm4gMDsKIAl9CiAKLQljaGlsZF9jdHggPSBjaGlsZC0+cGVyZl9ldmVudF9jdHhwW2N0 eG5dOworCWNoaWxkX2N0eCA9IHBhcmFtcy0+Y2hpbGQtPnBlcmZfZXZlbnRfY3R4cFtwYXJh bXMtPmN0eG5dOwogCWlmICghY2hpbGRfY3R4KSB7CiAJCS8qCiAJCSAqIFRoaXMgaXMgZXhl Y3V0ZWQgZnJvbSB0aGUgcGFyZW50IHRhc2sgY29udGV4dCwgc28KQEAgLTEwODAwLDE4ICsx MTA5NiwxOSBAQCBpbmhlcml0X3Rhc2tfZ3JvdXAoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50 LCBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnBhcmVudCwKIAkJICogRmlyc3QgYWxsb2NhdGUgYW5k IGluaXRpYWxpemUgYSBjb250ZXh0IGZvciB0aGUKIAkJICogY2hpbGQuCiAJCSAqLwotCQlj aGlsZF9jdHggPSBhbGxvY19wZXJmX2NvbnRleHQocGFyZW50X2N0eC0+cG11LCBjaGlsZCk7 CisJCWNoaWxkX2N0eCA9IGFsbG9jX3BlcmZfY29udGV4dChwYXJhbXMtPnBhcmVudF9jdHgt PnBtdSwKKwkJCQlwYXJhbXMtPmNoaWxkKTsKIAkJaWYgKCFjaGlsZF9jdHgpCiAJCQlyZXR1 cm4gLUVOT01FTTsKIAotCQljaGlsZC0+cGVyZl9ldmVudF9jdHhwW2N0eG5dID0gY2hpbGRf Y3R4OworCQlwYXJhbXMtPmNoaWxkLT5wZXJmX2V2ZW50X2N0eHBbcGFyYW1zLT5jdHhuXSA9 IGNoaWxkX2N0eDsKIAl9CiAKLQlyZXQgPSBpbmhlcml0X2dyb3VwKGV2ZW50LCBwYXJlbnQs IHBhcmVudF9jdHgsCi0JCQkgICAgY2hpbGQsIGNoaWxkX2N0eCk7CisJcmV0ID0gaW5oZXJp dF9ncm91cChldmVudCwgcGFyYW1zLT5wYXJlbnQsIHBhcmFtcy0+cGFyZW50X2N0eCwKKwkJ CSAgICBwYXJhbXMtPmNoaWxkLCBjaGlsZF9jdHgpOwogCiAJaWYgKHJldCkKLQkJKmluaGVy aXRlZF9hbGwgPSAwOworCQlwYXJhbXMtPmluaGVyaXRlZF9hbGwgPSAwOwogCiAJcmV0dXJu IHJldDsKIH0KQEAgLTEwODIzLDExICsxMTEyMCwxNSBAQCBzdGF0aWMgaW50IHBlcmZfZXZl bnRfaW5pdF9jb250ZXh0KHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQsIGludCBjdHhuKQog ewogCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmNoaWxkX2N0eCwgKnBhcmVudF9jdHg7 CiAJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY2xvbmVkX2N0eDsKLQlzdHJ1Y3QgcGVy Zl9ldmVudCAqZXZlbnQ7CiAJc3RydWN0IHRhc2tfc3RydWN0ICpwYXJlbnQgPSBjdXJyZW50 OwotCWludCBpbmhlcml0ZWRfYWxsID0gMTsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWlu dCByZXQgPSAwOworCXN0cnVjdCBpbmhlcml0X3Rhc2tfZ3JvdXBfcGFyYW1zIHBhcmFtcyA9 IHsKKwkJCS5wYXJlbnQgPSBwYXJlbnQsCisJCQkuY2hpbGQgPSBjaGlsZCwKKwkJCS5jdHhu ID0gY3R4biwKKwkJCS5pbmhlcml0ZWRfYWxsID0gMQorCX07CiAKIAlpZiAobGlrZWx5KCFw YXJlbnQtPnBlcmZfZXZlbnRfY3R4cFtjdHhuXSkpCiAJCXJldHVybiAwOwpAQCAtMTA4NDAs NiArMTExNDEsOCBAQCBzdGF0aWMgaW50IHBlcmZfZXZlbnRfaW5pdF9jb250ZXh0KHN0cnVj dCB0YXNrX3N0cnVjdCAqY2hpbGQsIGludCBjdHhuKQogCWlmICghcGFyZW50X2N0eCkKIAkJ cmV0dXJuIDA7CiAKKwlwYXJhbXMucGFyZW50X2N0eCA9IHBhcmVudF9jdHg7CisKIAkvKgog CSAqIE5vIG5lZWQgdG8gY2hlY2sgaWYgcGFyZW50X2N0eCAhPSBOVUxMIGhlcmU7IHNpbmNl IHdlIHNhdwogCSAqIGl0IG5vbi1OVUxMIGVhcmxpZXIsIHRoZSBvbmx5IHJlYXNvbiBmb3Ig aXQgdG8gYmVjb21lIE5VTEwKQEAgLTEwODU3LDEzICsxMTE2MCwxMCBAQCBzdGF0aWMgaW50 IHBlcmZfZXZlbnRfaW5pdF9jb250ZXh0KHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQsIGlu dCBjdHhuKQogCSAqIFdlIGRvbnQgaGF2ZSB0byBkaXNhYmxlIE5NSXMgLSB3ZSBhcmUgb25s eSBsb29raW5nIGF0CiAJICogdGhlIGxpc3QsIG5vdCBtYW5pcHVsYXRpbmcgaXQ6CiAJICov Ci0JbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJnBhcmVudF9jdHgtPnBpbm5lZF9ncm91 cHMsIGdyb3VwX2VudHJ5KSB7Ci0JCXJldCA9IGluaGVyaXRfdGFza19ncm91cChldmVudCwg cGFyZW50LCBwYXJlbnRfY3R4LAotCQkJCQkgY2hpbGQsIGN0eG4sICZpbmhlcml0ZWRfYWxs KTsKLQkJaWYgKHJldCkKLQkJCWdvdG8gb3V0X3VubG9jazsKLQl9Ci0KKwlyZXQgPSBwZXJm X2V2ZW50X2dyb3Vwc19pdGVyYXRlKCZwYXJlbnRfY3R4LT5waW5uZWRfZ3JvdXBzLAorCQkJ aW5oZXJpdF90YXNrX2dyb3VwLCAmcGFyYW1zKTsKKwlpZiAocmV0KQorCQlnb3RvIG91dF91 bmxvY2s7CiAJLyoKIAkgKiBXZSBjYW4ndCBob2xkIGN0eC0+bG9jayB3aGVuIGl0ZXJhdGlu ZyB0aGUgLT5mbGV4aWJsZV9ncm91cCBsaXN0IGR1ZQogCSAqIHRvIGFsbG9jYXRpb25zLCBi dXQgd2UgbmVlZCB0byBwcmV2ZW50IHJvdGF0aW9uIGJlY2F1c2UKQEAgLTEwODczLDE5ICsx MTE3MywxNyBAQCBzdGF0aWMgaW50IHBlcmZfZXZlbnRfaW5pdF9jb250ZXh0KHN0cnVjdCB0 YXNrX3N0cnVjdCAqY2hpbGQsIGludCBjdHhuKQogCXBhcmVudF9jdHgtPnJvdGF0ZV9kaXNh YmxlID0gMTsKIAlyYXdfc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcGFyZW50X2N0eC0+bG9j aywgZmxhZ3MpOwogCi0JbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJnBhcmVudF9jdHgt PmZsZXhpYmxlX2dyb3VwcywgZ3JvdXBfZW50cnkpIHsKLQkJcmV0ID0gaW5oZXJpdF90YXNr X2dyb3VwKGV2ZW50LCBwYXJlbnQsIHBhcmVudF9jdHgsCi0JCQkJCSBjaGlsZCwgY3R4biwg JmluaGVyaXRlZF9hbGwpOwotCQlpZiAocmV0KQotCQkJZ290byBvdXRfdW5sb2NrOwotCX0K KwlyZXQgPSBwZXJmX2V2ZW50X2dyb3Vwc19pdGVyYXRlKCZwYXJlbnRfY3R4LT5mbGV4aWJs ZV9ncm91cHMsCisJCQlpbmhlcml0X3Rhc2tfZ3JvdXAsICZwYXJhbXMpOworCWlmIChyZXQp CisJCWdvdG8gb3V0X3VubG9jazsKIAogCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmcGFyZW50 X2N0eC0+bG9jaywgZmxhZ3MpOwogCXBhcmVudF9jdHgtPnJvdGF0ZV9kaXNhYmxlID0gMDsK IAogCWNoaWxkX2N0eCA9IGNoaWxkLT5wZXJmX2V2ZW50X2N0eHBbY3R4bl07CiAKLQlpZiAo Y2hpbGRfY3R4ICYmIGluaGVyaXRlZF9hbGwpIHsKKwlpZiAoY2hpbGRfY3R4ICYmIHBhcmFt cy5pbmhlcml0ZWRfYWxsKSB7CiAJCS8qCiAJCSAqIE1hcmsgdGhlIGNoaWxkIGNvbnRleHQg YXMgYSBjbG9uZSBvZiB0aGUgcGFyZW50CiAJCSAqIGNvbnRleHQsIG9yIG9mIHdoYXRldmVy IHRoZSBwYXJlbnQgaXMgYSBjbG9uZSBvZi4K --------------68C52A70A0F669AA86980081--