From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752026AbbJ3FBN (ORCPT ); Fri, 30 Oct 2015 01:01:13 -0400 Received: from mail-pa0-f41.google.com ([209.85.220.41]:35152 "EHLO mail-pa0-f41.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750801AbbJ3FBL (ORCPT ); Fri, 30 Oct 2015 01:01:11 -0400 Date: Thu, 29 Oct 2015 22:01:07 -0700 From: Tina Ruchandani To: netdev@vger.kernel.org Cc: Arnd Bergmann , Karsten Keil , linux-kernel@vger.kernel.org, David Miller , y2038 Subject: [PATCH] NET: ATM: MPOA: Remove 32-bit timekeeping Message-ID: <20151030050107.GA10611@google.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline User-Agent: Mutt/1.5.21 (2010-09-15) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org net/atm/mpoa_* files use 'struct timeval' to store event timestamps. struct timeval uses a 32-bit seconds field which will overflow in the year 2038 and beyond. Morever, the timestamps are being compared only to get seconds elapsed, so struct timeval which stores a seconds and microseconds field is an overkill. This patch replaces the use of struct timeval with time64_t to store a 64-bit seconds field. Signed-off-by: Tina Ruchandani --- net/atm/common.c | 2 +- net/atm/mpc.c | 9 +++++---- net/atm/mpoa_caches.c | 49 ++++++++++++++++++++++++------------------------- net/atm/mpoa_caches.h | 9 +++++---- net/atm/mpoa_proc.c | 15 +++++++++------ 5 files changed, 44 insertions(+), 40 deletions(-) diff --git a/net/atm/common.c b/net/atm/common.c index 49a872d..a48a1ac 100644 --- a/net/atm/common.c +++ b/net/atm/common.c @@ -14,7 +14,7 @@ #include #include #include -#include /* struct timeval */ +#include /* 64-bit time for seconds */ #include #include #include diff --git a/net/atm/mpc.c b/net/atm/mpc.c index 0e98222..211468e 100644 --- a/net/atm/mpc.c +++ b/net/atm/mpc.c @@ -1090,7 +1090,7 @@ static void MPOA_trigger_rcvd(struct k_message *msg, struct mpoa_client *mpc) msg->type = SND_MPOA_RES_RQST; msg->content.in_info = entry->ctrl_info; msg_to_mpoad(msg, mpc); - do_gettimeofday(&(entry->reply_wait)); + entry->reply_wait = ktime_get_real_seconds(); mpc->in_ops->put(entry); return; } @@ -1100,7 +1100,7 @@ static void MPOA_trigger_rcvd(struct k_message *msg, struct mpoa_client *mpc) msg->type = SND_MPOA_RES_RQST; msg->content.in_info = entry->ctrl_info; msg_to_mpoad(msg, mpc); - do_gettimeofday(&(entry->reply_wait)); + entry->reply_wait = ktime_get_real_seconds(); mpc->in_ops->put(entry); return; } @@ -1176,8 +1176,9 @@ static void MPOA_res_reply_rcvd(struct k_message *msg, struct mpoa_client *mpc) } entry->ctrl_info = msg->content.in_info; - do_gettimeofday(&(entry->tv)); - do_gettimeofday(&(entry->reply_wait)); /* Used in refreshing func from now on */ + entry->tv = ktime_get_real_seconds(); + /* Used in refreshing func from now on */ + entry->reply_wait = ktime_get_real_seconds(); entry->refresh_time = 0; ddprintk_cont("entry->shortcut = %p\n", entry->shortcut); diff --git a/net/atm/mpoa_caches.c b/net/atm/mpoa_caches.c index d1b2d9a..2a59830 100644 --- a/net/atm/mpoa_caches.c +++ b/net/atm/mpoa_caches.c @@ -116,7 +116,7 @@ static in_cache_entry *in_cache_add_entry(__be32 dst_ip, memcpy(entry->MPS_ctrl_ATM_addr, client->mps_ctrl_addr, ATM_ESA_LEN); entry->ctrl_info.in_dst_ip = dst_ip; - do_gettimeofday(&(entry->tv)); + entry->tv = ktime_get_real_seconds(); entry->retry_time = client->parameters.mpc_p4; entry->count = 1; entry->entry_state = INGRESS_INVALID; @@ -147,7 +147,7 @@ static int cache_hit(in_cache_entry *entry, struct mpoa_client *mpc) if (qos != NULL) msg.qos = qos->qos; msg_to_mpoad(&msg, mpc); - do_gettimeofday(&(entry->reply_wait)); + entry->reply_wait = ktime_get_real_seconds(); entry->entry_state = INGRESS_RESOLVING; } if (entry->shortcut != NULL) @@ -170,7 +170,7 @@ static int cache_hit(in_cache_entry *entry, struct mpoa_client *mpc) if (qos != NULL) msg.qos = qos->qos; msg_to_mpoad(&msg, mpc); - do_gettimeofday(&(entry->reply_wait)); + entry->reply_wait = ktime_get_real_seconds(); } return CLOSED; @@ -226,17 +226,16 @@ static void in_cache_remove_entry(in_cache_entry *entry, static void clear_count_and_expired(struct mpoa_client *client) { in_cache_entry *entry, *next_entry; - struct timeval now; + time64_t now; - do_gettimeofday(&now); + now = ktime_get_real_seconds(); write_lock_bh(&client->ingress_lock); entry = client->in_cache; while (entry != NULL) { entry->count = 0; next_entry = entry->next; - if ((now.tv_sec - entry->tv.tv_sec) - > entry->ctrl_info.holding_time) { + if ((now - entry->tv) > entry->ctrl_info.holding_time) { dprintk("holding time expired, ip = %pI4\n", &entry->ctrl_info.in_dst_ip); client->in_ops->remove_entry(entry, client); @@ -252,35 +251,36 @@ static void check_resolving_entries(struct mpoa_client *client) struct atm_mpoa_qos *qos; in_cache_entry *entry; - struct timeval now; + time64_t now; struct k_message msg; - do_gettimeofday(&now); + now = ktime_get_real_seconds(); read_lock_bh(&client->ingress_lock); entry = client->in_cache; while (entry != NULL) { if (entry->entry_state == INGRESS_RESOLVING) { - if ((now.tv_sec - entry->hold_down.tv_sec) < - client->parameters.mpc_p6) { + + if ((now - entry->hold_down) + < client->parameters.mpc_p6) { entry = entry->next; /* Entry in hold down */ continue; } - if ((now.tv_sec - entry->reply_wait.tv_sec) > - entry->retry_time) { + if ((now - entry->reply_wait) > entry->retry_time) { entry->retry_time = MPC_C1 * (entry->retry_time); /* * Retry time maximum exceeded, * put entry in hold down. */ if (entry->retry_time > client->parameters.mpc_p5) { - do_gettimeofday(&(entry->hold_down)); + entry->hold_down = + ktime_get_real_seconds(); entry->retry_time = client->parameters.mpc_p4; entry = entry->next; continue; } /* Ask daemon to send a resolution request. */ - memset(&(entry->hold_down), 0, sizeof(struct timeval)); + memset(&entry->hold_down, 0, sizeof(time64_t)); msg.type = SND_MPOA_RES_RTRY; memcpy(msg.MPS_ctrl, client->mps_ctrl_addr, ATM_ESA_LEN); msg.content.in_info = entry->ctrl_info; @@ -288,7 +288,7 @@ static void check_resolving_entries(struct mpoa_client *client) if (qos != NULL) msg.qos = qos->qos; msg_to_mpoad(&msg, client); - do_gettimeofday(&(entry->reply_wait)); + entry->reply_wait = ktime_get_real_seconds(); } } entry = entry->next; @@ -299,18 +299,18 @@ static void check_resolving_entries(struct mpoa_client *client) /* Call this every MPC-p5 seconds. */ static void refresh_entries(struct mpoa_client *client) { - struct timeval now; + time64_t now; struct in_cache_entry *entry = client->in_cache; ddprintk("refresh_entries\n"); - do_gettimeofday(&now); + now = ktime_get_real_seconds(); read_lock_bh(&client->ingress_lock); while (entry != NULL) { if (entry->entry_state == INGRESS_RESOLVED) { if (!(entry->refresh_time)) entry->refresh_time = (2 * (entry->ctrl_info.holding_time))/3; - if ((now.tv_sec - entry->reply_wait.tv_sec) > + if ((now - entry->reply_wait) > entry->refresh_time) { dprintk("refreshing an entry.\n"); entry->entry_state = INGRESS_REFRESHING; @@ -479,7 +479,7 @@ static eg_cache_entry *eg_cache_add_entry(struct k_message *msg, memcpy(entry->MPS_ctrl_ATM_addr, client->mps_ctrl_addr, ATM_ESA_LEN); entry->ctrl_info = msg->content.eg_info; - do_gettimeofday(&(entry->tv)); + entry->tv = ktime_get_real_seconds(); entry->entry_state = EGRESS_RESOLVED; dprintk("new_eg_cache_entry cache_id %u\n", ntohl(entry->ctrl_info.cache_id)); @@ -494,7 +494,7 @@ static eg_cache_entry *eg_cache_add_entry(struct k_message *msg, static void update_eg_cache_entry(eg_cache_entry *entry, uint16_t holding_time) { - do_gettimeofday(&(entry->tv)); + entry->tv = ktime_get_real_seconds(); entry->entry_state = EGRESS_RESOLVED; entry->ctrl_info.holding_time = holding_time; } @@ -502,17 +502,16 @@ static void update_eg_cache_entry(eg_cache_entry *entry, uint16_t holding_time) static void clear_expired(struct mpoa_client *client) { eg_cache_entry *entry, *next_entry; - struct timeval now; + time64_t now; struct k_message msg; - do_gettimeofday(&now); + now = ktime_get_real_seconds(); write_lock_irq(&client->egress_lock); entry = client->eg_cache; while (entry != NULL) { next_entry = entry->next; - if ((now.tv_sec - entry->tv.tv_sec) - > entry->ctrl_info.holding_time) { + if ((now - entry->tv) > entry->ctrl_info.holding_time) { msg.type = SND_EGRESS_PURGE; msg.content.eg_info = entry->ctrl_info; dprintk("egress_cache: holding time expired, cache_id = %u.\n", diff --git a/net/atm/mpoa_caches.h b/net/atm/mpoa_caches.h index 8e5f78c..874fded 100644 --- a/net/atm/mpoa_caches.h +++ b/net/atm/mpoa_caches.h @@ -1,6 +1,7 @@ #ifndef MPOA_CACHES_H #define MPOA_CACHES_H +#include #include #include #include @@ -14,9 +15,9 @@ void atm_mpoa_init_cache(struct mpoa_client *mpc); typedef struct in_cache_entry { struct in_cache_entry *next; struct in_cache_entry *prev; - struct timeval tv; - struct timeval reply_wait; - struct timeval hold_down; + time64_t tv; + time64_t reply_wait; + time64_t hold_down; uint32_t packets_fwded; uint16_t entry_state; uint32_t retry_time; @@ -51,7 +52,7 @@ struct in_cache_ops{ typedef struct eg_cache_entry{ struct eg_cache_entry *next; struct eg_cache_entry *prev; - struct timeval tv; + time64_t tv; uint8_t MPS_ctrl_ATM_addr[ATM_ESA_LEN]; struct atm_vcc *shortcut; uint32_t packets_rcvd; diff --git a/net/atm/mpoa_proc.c b/net/atm/mpoa_proc.c index 2df34eb..06f2920 100644 --- a/net/atm/mpoa_proc.c +++ b/net/atm/mpoa_proc.c @@ -7,7 +7,7 @@ #include #include #include -#include +#include #include #include #include @@ -137,7 +137,7 @@ static int mpc_show(struct seq_file *m, void *v) int i; in_cache_entry *in_entry; eg_cache_entry *eg_entry; - struct timeval now; + time64_t now; unsigned char ip_string[16]; if (v == SEQ_START_TOKEN) { @@ -147,15 +147,17 @@ static int mpc_show(struct seq_file *m, void *v) seq_printf(m, "\nInterface %d:\n\n", mpc->dev_num); seq_printf(m, "Ingress Entries:\nIP address State Holding time Packets fwded VPI VCI\n"); - do_gettimeofday(&now); + now = ktime_get_real_seconds(); for (in_entry = mpc->in_cache; in_entry; in_entry = in_entry->next) { + unsigned long seconds_delta = now - in_entry->tv; + sprintf(ip_string, "%pI4", &in_entry->ctrl_info.in_dst_ip); seq_printf(m, "%-16s%s%-14lu%-12u", ip_string, ingress_state_string(in_entry->entry_state), in_entry->ctrl_info.holding_time - - (now.tv_sec-in_entry->tv.tv_sec), + seconds_delta, in_entry->packets_fwded); if (in_entry->shortcut) seq_printf(m, " %-3d %-3d", @@ -168,13 +170,14 @@ static int mpc_show(struct seq_file *m, void *v) seq_printf(m, "Egress Entries:\nIngress MPC ATM addr\nCache-id State Holding time Packets recvd Latest IP addr VPI VCI\n"); for (eg_entry = mpc->eg_cache; eg_entry; eg_entry = eg_entry->next) { unsigned char *p = eg_entry->ctrl_info.in_MPC_data_ATM_addr; + unsigned long seconds_delta = now - eg_entry->tv; + for (i = 0; i < ATM_ESA_LEN; i++) seq_printf(m, "%02x", p[i]); seq_printf(m, "\n%-16lu%s%-14lu%-15u", (unsigned long)ntohl(eg_entry->ctrl_info.cache_id), egress_state_string(eg_entry->entry_state), - (eg_entry->ctrl_info.holding_time - - (now.tv_sec-eg_entry->tv.tv_sec)), + (eg_entry->ctrl_info.holding_time - seconds_delta), eg_entry->packets_rcvd); /* latest IP address */ -- 2.6.0.rc2.230.g3dd15c0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Tina Ruchandani Subject: [PATCH] NET: ATM: MPOA: Remove 32-bit timekeeping Date: Thu, 29 Oct 2015 22:01:07 -0700 Message-ID: <20151030050107.GA10611@google.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Cc: y2038 , Karsten Keil , linux-kernel@vger.kernel.org, Arnd Bergmann , David Miller To: netdev@vger.kernel.org Return-path: Content-Disposition: inline List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: y2038-bounces@lists.linaro.org Sender: "Y2038" List-Id: netdev.vger.kernel.org bmV0L2F0bS9tcG9hXyogZmlsZXMgdXNlICdzdHJ1Y3QgdGltZXZhbCcgdG8gc3RvcmUgZXZlbnQK dGltZXN0YW1wcy4gc3RydWN0IHRpbWV2YWwgdXNlcyBhIDMyLWJpdCBzZWNvbmRzIGZpZWxkIHdo aWNoIHdpbGwKb3ZlcmZsb3cgaW4gdGhlIHllYXIgMjAzOCBhbmQgYmV5b25kLiBNb3JldmVyLCB0 aGUgdGltZXN0YW1wcyBhcmUgYmVpbmcKY29tcGFyZWQgb25seSB0byBnZXQgc2Vjb25kcyBlbGFw c2VkLCBzbyBzdHJ1Y3QgdGltZXZhbCB3aGljaCBzdG9yZXMKYSBzZWNvbmRzIGFuZCBtaWNyb3Nl Y29uZHMgZmllbGQgaXMgYW4gb3ZlcmtpbGwuIFRoaXMgcGF0Y2ggcmVwbGFjZXMKdGhlIHVzZSBv ZiBzdHJ1Y3QgdGltZXZhbCB3aXRoIHRpbWU2NF90IHRvIHN0b3JlIGEgNjQtYml0IHNlY29uZHMg ZmllbGQuCgpTaWduZWQtb2ZmLWJ5OiBUaW5hIFJ1Y2hhbmRhbmkgPHJ1Y2hhbmRhbmkudGluYUBn bWFpbC5jb20+Ci0tLQogbmV0L2F0bS9jb21tb24uYyAgICAgIHwgIDIgKy0KIG5ldC9hdG0vbXBj LmMgICAgICAgICB8ICA5ICsrKysrLS0tLQogbmV0L2F0bS9tcG9hX2NhY2hlcy5jIHwgNDkgKysr KysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogbmV0L2F0bS9t cG9hX2NhY2hlcy5oIHwgIDkgKysrKystLS0tCiBuZXQvYXRtL21wb2FfcHJvYy5jICAgfCAxNSAr KysrKysrKystLS0tLS0KIDUgZmlsZXMgY2hhbmdlZCwgNDQgaW5zZXJ0aW9ucygrKSwgNDAgZGVs ZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvbmV0L2F0bS9jb21tb24uYyBiL25ldC9hdG0vY29tbW9u LmMKaW5kZXggNDlhODcyZC4uYTQ4YTFhYyAxMDA2NDQKLS0tIGEvbmV0L2F0bS9jb21tb24uYwor KysgYi9uZXQvYXRtL2NvbW1vbi5jCkBAIC0xNCw3ICsxNCw3IEBACiAjaW5jbHVkZSA8bGludXgv Y2FwYWJpbGl0eS5oPgogI2luY2x1ZGUgPGxpbnV4L21tLmg+CiAjaW5jbHVkZSA8bGludXgvc2No ZWQuaD4KLSNpbmNsdWRlIDxsaW51eC90aW1lLmg+CQkvKiBzdHJ1Y3QgdGltZXZhbCAqLworI2lu Y2x1ZGUgPGxpbnV4L3RpbWU2NC5oPgkvKiA2NC1iaXQgdGltZSBmb3Igc2Vjb25kcyAqLwogI2lu Y2x1ZGUgPGxpbnV4L3NrYnVmZi5oPgogI2luY2x1ZGUgPGxpbnV4L2JpdG9wcy5oPgogI2luY2x1 ZGUgPGxpbnV4L2luaXQuaD4KZGlmZiAtLWdpdCBhL25ldC9hdG0vbXBjLmMgYi9uZXQvYXRtL21w Yy5jCmluZGV4IDBlOTgyMjIuLjIxMTQ2OGUgMTAwNjQ0Ci0tLSBhL25ldC9hdG0vbXBjLmMKKysr IGIvbmV0L2F0bS9tcGMuYwpAQCAtMTA5MCw3ICsxMDkwLDcgQEAgc3RhdGljIHZvaWQgTVBPQV90 cmlnZ2VyX3JjdmQoc3RydWN0IGtfbWVzc2FnZSAqbXNnLCBzdHJ1Y3QgbXBvYV9jbGllbnQgKm1w YykKIAkJbXNnLT50eXBlID0gU05EX01QT0FfUkVTX1JRU1Q7CiAJCW1zZy0+Y29udGVudC5pbl9p bmZvID0gZW50cnktPmN0cmxfaW5mbzsKIAkJbXNnX3RvX21wb2FkKG1zZywgbXBjKTsKLQkJZG9f Z2V0dGltZW9mZGF5KCYoZW50cnktPnJlcGx5X3dhaXQpKTsKKwkJZW50cnktPnJlcGx5X3dhaXQg PSBrdGltZV9nZXRfcmVhbF9zZWNvbmRzKCk7CiAJCW1wYy0+aW5fb3BzLT5wdXQoZW50cnkpOwog CQlyZXR1cm47CiAJfQpAQCAtMTEwMCw3ICsxMTAwLDcgQEAgc3RhdGljIHZvaWQgTVBPQV90cmln Z2VyX3JjdmQoc3RydWN0IGtfbWVzc2FnZSAqbXNnLCBzdHJ1Y3QgbXBvYV9jbGllbnQgKm1wYykK IAkJbXNnLT50eXBlID0gU05EX01QT0FfUkVTX1JRU1Q7CiAJCW1zZy0+Y29udGVudC5pbl9pbmZv ID0gZW50cnktPmN0cmxfaW5mbzsKIAkJbXNnX3RvX21wb2FkKG1zZywgbXBjKTsKLQkJZG9fZ2V0 dGltZW9mZGF5KCYoZW50cnktPnJlcGx5X3dhaXQpKTsKKwkJZW50cnktPnJlcGx5X3dhaXQgPSBr dGltZV9nZXRfcmVhbF9zZWNvbmRzKCk7CiAJCW1wYy0+aW5fb3BzLT5wdXQoZW50cnkpOwogCQly ZXR1cm47CiAJfQpAQCAtMTE3Niw4ICsxMTc2LDkgQEAgc3RhdGljIHZvaWQgTVBPQV9yZXNfcmVw bHlfcmN2ZChzdHJ1Y3Qga19tZXNzYWdlICptc2csIHN0cnVjdCBtcG9hX2NsaWVudCAqbXBjKQog CX0KIAogCWVudHJ5LT5jdHJsX2luZm8gPSBtc2ctPmNvbnRlbnQuaW5faW5mbzsKLQlkb19nZXR0 aW1lb2ZkYXkoJihlbnRyeS0+dHYpKTsKLQlkb19nZXR0aW1lb2ZkYXkoJihlbnRyeS0+cmVwbHlf d2FpdCkpOyAvKiBVc2VkIGluIHJlZnJlc2hpbmcgZnVuYyBmcm9tIG5vdyBvbiAqLworCWVudHJ5 LT50diA9IGt0aW1lX2dldF9yZWFsX3NlY29uZHMoKTsKKwkvKiBVc2VkIGluIHJlZnJlc2hpbmcg ZnVuYyBmcm9tIG5vdyBvbiAqLworCWVudHJ5LT5yZXBseV93YWl0ID0ga3RpbWVfZ2V0X3JlYWxf c2Vjb25kcygpOwogCWVudHJ5LT5yZWZyZXNoX3RpbWUgPSAwOwogCWRkcHJpbnRrX2NvbnQoImVu dHJ5LT5zaG9ydGN1dCA9ICVwXG4iLCBlbnRyeS0+c2hvcnRjdXQpOwogCmRpZmYgLS1naXQgYS9u ZXQvYXRtL21wb2FfY2FjaGVzLmMgYi9uZXQvYXRtL21wb2FfY2FjaGVzLmMKaW5kZXggZDFiMmQ5 YS4uMmE1OTgzMCAxMDA2NDQKLS0tIGEvbmV0L2F0bS9tcG9hX2NhY2hlcy5jCisrKyBiL25ldC9h dG0vbXBvYV9jYWNoZXMuYwpAQCAtMTE2LDcgKzExNiw3IEBAIHN0YXRpYyBpbl9jYWNoZV9lbnRy eSAqaW5fY2FjaGVfYWRkX2VudHJ5KF9fYmUzMiBkc3RfaXAsCiAKIAltZW1jcHkoZW50cnktPk1Q U19jdHJsX0FUTV9hZGRyLCBjbGllbnQtPm1wc19jdHJsX2FkZHIsIEFUTV9FU0FfTEVOKTsKIAll bnRyeS0+Y3RybF9pbmZvLmluX2RzdF9pcCA9IGRzdF9pcDsKLQlkb19nZXR0aW1lb2ZkYXkoJihl bnRyeS0+dHYpKTsKKwllbnRyeS0+dHYgPSBrdGltZV9nZXRfcmVhbF9zZWNvbmRzKCk7CiAJZW50 cnktPnJldHJ5X3RpbWUgPSBjbGllbnQtPnBhcmFtZXRlcnMubXBjX3A0OwogCWVudHJ5LT5jb3Vu dCA9IDE7CiAJZW50cnktPmVudHJ5X3N0YXRlID0gSU5HUkVTU19JTlZBTElEOwpAQCAtMTQ3LDcg KzE0Nyw3IEBAIHN0YXRpYyBpbnQgY2FjaGVfaGl0KGluX2NhY2hlX2VudHJ5ICplbnRyeSwgc3Ry dWN0IG1wb2FfY2xpZW50ICptcGMpCiAJCQlpZiAocW9zICE9IE5VTEwpCiAJCQkJbXNnLnFvcyA9 IHFvcy0+cW9zOwogCQkJbXNnX3RvX21wb2FkKCZtc2csIG1wYyk7Ci0JCQlkb19nZXR0aW1lb2Zk YXkoJihlbnRyeS0+cmVwbHlfd2FpdCkpOworCQkJZW50cnktPnJlcGx5X3dhaXQgPSBrdGltZV9n ZXRfcmVhbF9zZWNvbmRzKCk7CiAJCQllbnRyeS0+ZW50cnlfc3RhdGUgPSBJTkdSRVNTX1JFU09M VklORzsKIAkJfQogCQlpZiAoZW50cnktPnNob3J0Y3V0ICE9IE5VTEwpCkBAIC0xNzAsNyArMTcw LDcgQEAgc3RhdGljIGludCBjYWNoZV9oaXQoaW5fY2FjaGVfZW50cnkgKmVudHJ5LCBzdHJ1Y3Qg bXBvYV9jbGllbnQgKm1wYykKIAkJaWYgKHFvcyAhPSBOVUxMKQogCQkJbXNnLnFvcyA9IHFvcy0+ cW9zOwogCQltc2dfdG9fbXBvYWQoJm1zZywgbXBjKTsKLQkJZG9fZ2V0dGltZW9mZGF5KCYoZW50 cnktPnJlcGx5X3dhaXQpKTsKKwkJZW50cnktPnJlcGx5X3dhaXQgPSBrdGltZV9nZXRfcmVhbF9z ZWNvbmRzKCk7CiAJfQogCiAJcmV0dXJuIENMT1NFRDsKQEAgLTIyNiwxNyArMjI2LDE2IEBAIHN0 YXRpYyB2b2lkIGluX2NhY2hlX3JlbW92ZV9lbnRyeShpbl9jYWNoZV9lbnRyeSAqZW50cnksCiBz dGF0aWMgdm9pZCBjbGVhcl9jb3VudF9hbmRfZXhwaXJlZChzdHJ1Y3QgbXBvYV9jbGllbnQgKmNs aWVudCkKIHsKIAlpbl9jYWNoZV9lbnRyeSAqZW50cnksICpuZXh0X2VudHJ5OwotCXN0cnVjdCB0 aW1ldmFsIG5vdzsKKwl0aW1lNjRfdCBub3c7CiAKLQlkb19nZXR0aW1lb2ZkYXkoJm5vdyk7CisJ bm93ID0ga3RpbWVfZ2V0X3JlYWxfc2Vjb25kcygpOwogCiAJd3JpdGVfbG9ja19iaCgmY2xpZW50 LT5pbmdyZXNzX2xvY2spOwogCWVudHJ5ID0gY2xpZW50LT5pbl9jYWNoZTsKIAl3aGlsZSAoZW50 cnkgIT0gTlVMTCkgewogCQllbnRyeS0+Y291bnQgPSAwOwogCQluZXh0X2VudHJ5ID0gZW50cnkt Pm5leHQ7Ci0JCWlmICgobm93LnR2X3NlYyAtIGVudHJ5LT50di50dl9zZWMpCi0JCSAgID4gZW50 cnktPmN0cmxfaW5mby5ob2xkaW5nX3RpbWUpIHsKKwkJaWYgKChub3cgLSBlbnRyeS0+dHYpID4g ZW50cnktPmN0cmxfaW5mby5ob2xkaW5nX3RpbWUpIHsKIAkJCWRwcmludGsoImhvbGRpbmcgdGlt ZSBleHBpcmVkLCBpcCA9ICVwSTRcbiIsCiAJCQkJJmVudHJ5LT5jdHJsX2luZm8uaW5fZHN0X2lw KTsKIAkJCWNsaWVudC0+aW5fb3BzLT5yZW1vdmVfZW50cnkoZW50cnksIGNsaWVudCk7CkBAIC0y NTIsMzUgKzI1MSwzNiBAQCBzdGF0aWMgdm9pZCBjaGVja19yZXNvbHZpbmdfZW50cmllcyhzdHJ1 Y3QgbXBvYV9jbGllbnQgKmNsaWVudCkKIAogCXN0cnVjdCBhdG1fbXBvYV9xb3MgKnFvczsKIAlp bl9jYWNoZV9lbnRyeSAqZW50cnk7Ci0Jc3RydWN0IHRpbWV2YWwgbm93OworCXRpbWU2NF90IG5v dzsKIAlzdHJ1Y3Qga19tZXNzYWdlIG1zZzsKIAotCWRvX2dldHRpbWVvZmRheSgmbm93KTsKKwlu b3cgPSBrdGltZV9nZXRfcmVhbF9zZWNvbmRzKCk7CiAKIAlyZWFkX2xvY2tfYmgoJmNsaWVudC0+ aW5ncmVzc19sb2NrKTsKIAllbnRyeSA9IGNsaWVudC0+aW5fY2FjaGU7CiAJd2hpbGUgKGVudHJ5 ICE9IE5VTEwpIHsKIAkJaWYgKGVudHJ5LT5lbnRyeV9zdGF0ZSA9PSBJTkdSRVNTX1JFU09MVklO RykgewotCQkJaWYgKChub3cudHZfc2VjIC0gZW50cnktPmhvbGRfZG93bi50dl9zZWMpIDwKLQkJ CSAgICBjbGllbnQtPnBhcmFtZXRlcnMubXBjX3A2KSB7CisKKwkJCWlmICgobm93IC0gZW50cnkt PmhvbGRfZG93bikKKwkJCQkJPCBjbGllbnQtPnBhcmFtZXRlcnMubXBjX3A2KSB7CiAJCQkJZW50 cnkgPSBlbnRyeS0+bmV4dDsJLyogRW50cnkgaW4gaG9sZCBkb3duICovCiAJCQkJY29udGludWU7 CiAJCQl9Ci0JCQlpZiAoKG5vdy50dl9zZWMgLSBlbnRyeS0+cmVwbHlfd2FpdC50dl9zZWMpID4K LQkJCSAgICBlbnRyeS0+cmV0cnlfdGltZSkgeworCQkJaWYgKChub3cgLSBlbnRyeS0+cmVwbHlf d2FpdCkgPiBlbnRyeS0+cmV0cnlfdGltZSkgewogCQkJCWVudHJ5LT5yZXRyeV90aW1lID0gTVBD X0MxICogKGVudHJ5LT5yZXRyeV90aW1lKTsKIAkJCQkvKgogCQkJCSAqIFJldHJ5IHRpbWUgbWF4 aW11bSBleGNlZWRlZCwKIAkJCQkgKiBwdXQgZW50cnkgaW4gaG9sZCBkb3duLgogCQkJCSAqLwog CQkJCWlmIChlbnRyeS0+cmV0cnlfdGltZSA+IGNsaWVudC0+cGFyYW1ldGVycy5tcGNfcDUpIHsK LQkJCQkJZG9fZ2V0dGltZW9mZGF5KCYoZW50cnktPmhvbGRfZG93bikpOworCQkJCQllbnRyeS0+ aG9sZF9kb3duID0KKwkJCQkJCWt0aW1lX2dldF9yZWFsX3NlY29uZHMoKTsKIAkJCQkJZW50cnkt PnJldHJ5X3RpbWUgPSBjbGllbnQtPnBhcmFtZXRlcnMubXBjX3A0OwogCQkJCQllbnRyeSA9IGVu dHJ5LT5uZXh0OwogCQkJCQljb250aW51ZTsKIAkJCQl9CiAJCQkJLyogQXNrIGRhZW1vbiB0byBz ZW5kIGEgcmVzb2x1dGlvbiByZXF1ZXN0LiAqLwotCQkJCW1lbXNldCgmKGVudHJ5LT5ob2xkX2Rv d24pLCAwLCBzaXplb2Yoc3RydWN0IHRpbWV2YWwpKTsKKwkJCQltZW1zZXQoJmVudHJ5LT5ob2xk X2Rvd24sIDAsIHNpemVvZih0aW1lNjRfdCkpOwogCQkJCW1zZy50eXBlID0gU05EX01QT0FfUkVT X1JUUlk7CiAJCQkJbWVtY3B5KG1zZy5NUFNfY3RybCwgY2xpZW50LT5tcHNfY3RybF9hZGRyLCBB VE1fRVNBX0xFTik7CiAJCQkJbXNnLmNvbnRlbnQuaW5faW5mbyA9IGVudHJ5LT5jdHJsX2luZm87 CkBAIC0yODgsNyArMjg4LDcgQEAgc3RhdGljIHZvaWQgY2hlY2tfcmVzb2x2aW5nX2VudHJpZXMo c3RydWN0IG1wb2FfY2xpZW50ICpjbGllbnQpCiAJCQkJaWYgKHFvcyAhPSBOVUxMKQogCQkJCQlt c2cucW9zID0gcW9zLT5xb3M7CiAJCQkJbXNnX3RvX21wb2FkKCZtc2csIGNsaWVudCk7Ci0JCQkJ ZG9fZ2V0dGltZW9mZGF5KCYoZW50cnktPnJlcGx5X3dhaXQpKTsKKwkJCQllbnRyeS0+cmVwbHlf d2FpdCA9IGt0aW1lX2dldF9yZWFsX3NlY29uZHMoKTsKIAkJCX0KIAkJfQogCQllbnRyeSA9IGVu dHJ5LT5uZXh0OwpAQCAtMjk5LDE4ICsyOTksMTggQEAgc3RhdGljIHZvaWQgY2hlY2tfcmVzb2x2 aW5nX2VudHJpZXMoc3RydWN0IG1wb2FfY2xpZW50ICpjbGllbnQpCiAvKiBDYWxsIHRoaXMgZXZl cnkgTVBDLXA1IHNlY29uZHMuICovCiBzdGF0aWMgdm9pZCByZWZyZXNoX2VudHJpZXMoc3RydWN0 IG1wb2FfY2xpZW50ICpjbGllbnQpCiB7Ci0Jc3RydWN0IHRpbWV2YWwgbm93OworCXRpbWU2NF90 IG5vdzsKIAlzdHJ1Y3QgaW5fY2FjaGVfZW50cnkgKmVudHJ5ID0gY2xpZW50LT5pbl9jYWNoZTsK IAogCWRkcHJpbnRrKCJyZWZyZXNoX2VudHJpZXNcbiIpOwotCWRvX2dldHRpbWVvZmRheSgmbm93 KTsKKwlub3cgPSBrdGltZV9nZXRfcmVhbF9zZWNvbmRzKCk7CiAKIAlyZWFkX2xvY2tfYmgoJmNs aWVudC0+aW5ncmVzc19sb2NrKTsKIAl3aGlsZSAoZW50cnkgIT0gTlVMTCkgewogCQlpZiAoZW50 cnktPmVudHJ5X3N0YXRlID09IElOR1JFU1NfUkVTT0xWRUQpIHsKIAkJCWlmICghKGVudHJ5LT5y ZWZyZXNoX3RpbWUpKQogCQkJCWVudHJ5LT5yZWZyZXNoX3RpbWUgPSAoMiAqIChlbnRyeS0+Y3Ry bF9pbmZvLmhvbGRpbmdfdGltZSkpLzM7Ci0JCQlpZiAoKG5vdy50dl9zZWMgLSBlbnRyeS0+cmVw bHlfd2FpdC50dl9zZWMpID4KKwkJCWlmICgobm93IC0gZW50cnktPnJlcGx5X3dhaXQpID4KIAkJ CSAgICBlbnRyeS0+cmVmcmVzaF90aW1lKSB7CiAJCQkJZHByaW50aygicmVmcmVzaGluZyBhbiBl bnRyeS5cbiIpOwogCQkJCWVudHJ5LT5lbnRyeV9zdGF0ZSA9IElOR1JFU1NfUkVGUkVTSElORzsK QEAgLTQ3OSw3ICs0NzksNyBAQCBzdGF0aWMgZWdfY2FjaGVfZW50cnkgKmVnX2NhY2hlX2FkZF9l bnRyeShzdHJ1Y3Qga19tZXNzYWdlICptc2csCiAKIAltZW1jcHkoZW50cnktPk1QU19jdHJsX0FU TV9hZGRyLCBjbGllbnQtPm1wc19jdHJsX2FkZHIsIEFUTV9FU0FfTEVOKTsKIAllbnRyeS0+Y3Ry bF9pbmZvID0gbXNnLT5jb250ZW50LmVnX2luZm87Ci0JZG9fZ2V0dGltZW9mZGF5KCYoZW50cnkt PnR2KSk7CisJZW50cnktPnR2ID0ga3RpbWVfZ2V0X3JlYWxfc2Vjb25kcygpOwogCWVudHJ5LT5l bnRyeV9zdGF0ZSA9IEVHUkVTU19SRVNPTFZFRDsKIAlkcHJpbnRrKCJuZXdfZWdfY2FjaGVfZW50 cnkgY2FjaGVfaWQgJXVcbiIsCiAJCW50b2hsKGVudHJ5LT5jdHJsX2luZm8uY2FjaGVfaWQpKTsK QEAgLTQ5NCw3ICs0OTQsNyBAQCBzdGF0aWMgZWdfY2FjaGVfZW50cnkgKmVnX2NhY2hlX2FkZF9l bnRyeShzdHJ1Y3Qga19tZXNzYWdlICptc2csCiAKIHN0YXRpYyB2b2lkIHVwZGF0ZV9lZ19jYWNo ZV9lbnRyeShlZ19jYWNoZV9lbnRyeSAqZW50cnksIHVpbnQxNl90IGhvbGRpbmdfdGltZSkKIHsK LQlkb19nZXR0aW1lb2ZkYXkoJihlbnRyeS0+dHYpKTsKKwllbnRyeS0+dHYgPSBrdGltZV9nZXRf cmVhbF9zZWNvbmRzKCk7CiAJZW50cnktPmVudHJ5X3N0YXRlID0gRUdSRVNTX1JFU09MVkVEOwog CWVudHJ5LT5jdHJsX2luZm8uaG9sZGluZ190aW1lID0gaG9sZGluZ190aW1lOwogfQpAQCAtNTAy LDE3ICs1MDIsMTYgQEAgc3RhdGljIHZvaWQgdXBkYXRlX2VnX2NhY2hlX2VudHJ5KGVnX2NhY2hl X2VudHJ5ICplbnRyeSwgdWludDE2X3QgaG9sZGluZ190aW1lKQogc3RhdGljIHZvaWQgY2xlYXJf ZXhwaXJlZChzdHJ1Y3QgbXBvYV9jbGllbnQgKmNsaWVudCkKIHsKIAllZ19jYWNoZV9lbnRyeSAq ZW50cnksICpuZXh0X2VudHJ5OwotCXN0cnVjdCB0aW1ldmFsIG5vdzsKKwl0aW1lNjRfdCBub3c7 CiAJc3RydWN0IGtfbWVzc2FnZSBtc2c7CiAKLQlkb19nZXR0aW1lb2ZkYXkoJm5vdyk7CisJbm93 ID0ga3RpbWVfZ2V0X3JlYWxfc2Vjb25kcygpOwogCiAJd3JpdGVfbG9ja19pcnEoJmNsaWVudC0+ ZWdyZXNzX2xvY2spOwogCWVudHJ5ID0gY2xpZW50LT5lZ19jYWNoZTsKIAl3aGlsZSAoZW50cnkg IT0gTlVMTCkgewogCQluZXh0X2VudHJ5ID0gZW50cnktPm5leHQ7Ci0JCWlmICgobm93LnR2X3Nl YyAtIGVudHJ5LT50di50dl9zZWMpCi0JCSAgID4gZW50cnktPmN0cmxfaW5mby5ob2xkaW5nX3Rp bWUpIHsKKwkJaWYgKChub3cgLSBlbnRyeS0+dHYpID4gZW50cnktPmN0cmxfaW5mby5ob2xkaW5n X3RpbWUpIHsKIAkJCW1zZy50eXBlID0gU05EX0VHUkVTU19QVVJHRTsKIAkJCW1zZy5jb250ZW50 LmVnX2luZm8gPSBlbnRyeS0+Y3RybF9pbmZvOwogCQkJZHByaW50aygiZWdyZXNzX2NhY2hlOiBo b2xkaW5nIHRpbWUgZXhwaXJlZCwgY2FjaGVfaWQgPSAldS5cbiIsCmRpZmYgLS1naXQgYS9uZXQv YXRtL21wb2FfY2FjaGVzLmggYi9uZXQvYXRtL21wb2FfY2FjaGVzLmgKaW5kZXggOGU1Zjc4Yy4u ODc0ZmRlZCAxMDA2NDQKLS0tIGEvbmV0L2F0bS9tcG9hX2NhY2hlcy5oCisrKyBiL25ldC9hdG0v bXBvYV9jYWNoZXMuaApAQCAtMSw2ICsxLDcgQEAKICNpZm5kZWYgTVBPQV9DQUNIRVNfSAogI2Rl ZmluZSBNUE9BX0NBQ0hFU19ICiAKKyNpbmNsdWRlIDxsaW51eC90aW1lNjQuaD4KICNpbmNsdWRl IDxsaW51eC9uZXRkZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgogI2luY2x1ZGUg PGxpbnV4L2F0bS5oPgpAQCAtMTQsOSArMTUsOSBAQCB2b2lkIGF0bV9tcG9hX2luaXRfY2FjaGUo c3RydWN0IG1wb2FfY2xpZW50ICptcGMpOwogdHlwZWRlZiBzdHJ1Y3QgaW5fY2FjaGVfZW50cnkg ewogCXN0cnVjdCBpbl9jYWNoZV9lbnRyeSAqbmV4dDsKIAlzdHJ1Y3QgaW5fY2FjaGVfZW50cnkg KnByZXY7Ci0Jc3RydWN0IHRpbWV2YWwgIHR2OwotCXN0cnVjdCB0aW1ldmFsICByZXBseV93YWl0 OwotCXN0cnVjdCB0aW1ldmFsICBob2xkX2Rvd247CisJdGltZTY0X3QgIHR2OworCXRpbWU2NF90 ICByZXBseV93YWl0OworCXRpbWU2NF90ICBob2xkX2Rvd247CiAJdWludDMyX3QgIHBhY2tldHNf ZndkZWQ7CiAJdWludDE2X3QgIGVudHJ5X3N0YXRlOwogCXVpbnQzMl90IHJldHJ5X3RpbWU7CkBA IC01MSw3ICs1Miw3IEBAIHN0cnVjdCBpbl9jYWNoZV9vcHN7CiB0eXBlZGVmIHN0cnVjdCBlZ19j YWNoZV9lbnRyeXsKIAlzdHJ1Y3QgICAgICAgICAgICAgICBlZ19jYWNoZV9lbnRyeSAqbmV4dDsK IAlzdHJ1Y3QgICAgICAgICAgICAgICBlZ19jYWNoZV9lbnRyeSAqcHJldjsKLQlzdHJ1Y3QgICAg ICAgICAgICAgICB0aW1ldmFsICB0djsKKwl0aW1lNjRfdAkgICAgIHR2OwogCXVpbnQ4X3QgICAg ICAgICAgICAgIE1QU19jdHJsX0FUTV9hZGRyW0FUTV9FU0FfTEVOXTsKIAlzdHJ1Y3QgYXRtX3Zj YyAgICAgICAqc2hvcnRjdXQ7CiAJdWludDMyX3QgICAgICAgICAgICAgcGFja2V0c19yY3ZkOwpk aWZmIC0tZ2l0IGEvbmV0L2F0bS9tcG9hX3Byb2MuYyBiL25ldC9hdG0vbXBvYV9wcm9jLmMKaW5k ZXggMmRmMzRlYi4uMDZmMjkyMCAxMDA2NDQKLS0tIGEvbmV0L2F0bS9tcG9hX3Byb2MuYworKysg Yi9uZXQvYXRtL21wb2FfcHJvYy5jCkBAIC03LDcgKzcsNyBAQAogI2luY2x1ZGUgPGxpbnV4L21t Lmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvcHJvY19mcy5o PgotI2luY2x1ZGUgPGxpbnV4L3RpbWUuaD4KKyNpbmNsdWRlIDxsaW51eC9rdGltZS5oPgogI2lu Y2x1ZGUgPGxpbnV4L3NlcV9maWxlLmg+CiAjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgogI2lu Y2x1ZGUgPGxpbnV4L2F0bW1wYy5oPgpAQCAtMTM3LDcgKzEzNyw3IEBAIHN0YXRpYyBpbnQgbXBj X3Nob3coc3RydWN0IHNlcV9maWxlICptLCB2b2lkICp2KQogCWludCBpOwogCWluX2NhY2hlX2Vu dHJ5ICppbl9lbnRyeTsKIAllZ19jYWNoZV9lbnRyeSAqZWdfZW50cnk7Ci0Jc3RydWN0IHRpbWV2 YWwgbm93OworCXRpbWU2NF90IG5vdzsKIAl1bnNpZ25lZCBjaGFyIGlwX3N0cmluZ1sxNl07CiAK IAlpZiAodiA9PSBTRVFfU1RBUlRfVE9LRU4pIHsKQEAgLTE0NywxNSArMTQ3LDE3IEBAIHN0YXRp YyBpbnQgbXBjX3Nob3coc3RydWN0IHNlcV9maWxlICptLCB2b2lkICp2KQogCiAJc2VxX3ByaW50 ZihtLCAiXG5JbnRlcmZhY2UgJWQ6XG5cbiIsIG1wYy0+ZGV2X251bSk7CiAJc2VxX3ByaW50Ziht LCAiSW5ncmVzcyBFbnRyaWVzOlxuSVAgYWRkcmVzcyAgICAgIFN0YXRlICAgICAgSG9sZGluZyB0 aW1lICBQYWNrZXRzIGZ3ZGVkICBWUEkgIFZDSVxuIik7Ci0JZG9fZ2V0dGltZW9mZGF5KCZub3cp OworCW5vdyA9IGt0aW1lX2dldF9yZWFsX3NlY29uZHMoKTsKIAogCWZvciAoaW5fZW50cnkgPSBt cGMtPmluX2NhY2hlOyBpbl9lbnRyeTsgaW5fZW50cnkgPSBpbl9lbnRyeS0+bmV4dCkgeworCQl1 bnNpZ25lZCBsb25nIHNlY29uZHNfZGVsdGEgPSBub3cgLSBpbl9lbnRyeS0+dHY7CisKIAkJc3By aW50ZihpcF9zdHJpbmcsICIlcEk0IiwgJmluX2VudHJ5LT5jdHJsX2luZm8uaW5fZHN0X2lwKTsK IAkJc2VxX3ByaW50ZihtLCAiJS0xNnMlcyUtMTRsdSUtMTJ1IiwKIAkJCSAgIGlwX3N0cmluZywK IAkJCSAgIGluZ3Jlc3Nfc3RhdGVfc3RyaW5nKGluX2VudHJ5LT5lbnRyeV9zdGF0ZSksCiAJCQkg ICBpbl9lbnRyeS0+Y3RybF9pbmZvLmhvbGRpbmdfdGltZSAtCi0JCQkgICAobm93LnR2X3NlYy1p bl9lbnRyeS0+dHYudHZfc2VjKSwKKwkJCSAgIHNlY29uZHNfZGVsdGEsCiAJCQkgICBpbl9lbnRy eS0+cGFja2V0c19md2RlZCk7CiAJCWlmIChpbl9lbnRyeS0+c2hvcnRjdXQpCiAJCQlzZXFfcHJp bnRmKG0sICIgICAlLTNkICAlLTNkIiwKQEAgLTE2OCwxMyArMTcwLDE0IEBAIHN0YXRpYyBpbnQg bXBjX3Nob3coc3RydWN0IHNlcV9maWxlICptLCB2b2lkICp2KQogCXNlcV9wcmludGYobSwgIkVn cmVzcyBFbnRyaWVzOlxuSW5ncmVzcyBNUEMgQVRNIGFkZHJcbkNhY2hlLWlkICAgICAgICBTdGF0 ZSAgICAgIEhvbGRpbmcgdGltZSAgUGFja2V0cyByZWN2ZCAgTGF0ZXN0IElQIGFkZHIgICBWUEkg VkNJXG4iKTsKIAlmb3IgKGVnX2VudHJ5ID0gbXBjLT5lZ19jYWNoZTsgZWdfZW50cnk7IGVnX2Vu dHJ5ID0gZWdfZW50cnktPm5leHQpIHsKIAkJdW5zaWduZWQgY2hhciAqcCA9IGVnX2VudHJ5LT5j dHJsX2luZm8uaW5fTVBDX2RhdGFfQVRNX2FkZHI7CisJCXVuc2lnbmVkIGxvbmcgc2Vjb25kc19k ZWx0YSA9IG5vdyAtIGVnX2VudHJ5LT50djsKKwogCQlmb3IgKGkgPSAwOyBpIDwgQVRNX0VTQV9M RU47IGkrKykKIAkJCXNlcV9wcmludGYobSwgIiUwMngiLCBwW2ldKTsKIAkJc2VxX3ByaW50Ziht LCAiXG4lLTE2bHUlcyUtMTRsdSUtMTV1IiwKIAkJCSAgICh1bnNpZ25lZCBsb25nKW50b2hsKGVn X2VudHJ5LT5jdHJsX2luZm8uY2FjaGVfaWQpLAogCQkJICAgZWdyZXNzX3N0YXRlX3N0cmluZyhl Z19lbnRyeS0+ZW50cnlfc3RhdGUpLAotCQkJICAgKGVnX2VudHJ5LT5jdHJsX2luZm8uaG9sZGlu Z190aW1lIC0KLQkJCSAgICAobm93LnR2X3NlYy1lZ19lbnRyeS0+dHYudHZfc2VjKSksCisJCQkg ICAoZWdfZW50cnktPmN0cmxfaW5mby5ob2xkaW5nX3RpbWUgLSBzZWNvbmRzX2RlbHRhKSwKIAkJ CSAgIGVnX2VudHJ5LT5wYWNrZXRzX3JjdmQpOwogCiAJCS8qIGxhdGVzdCBJUCBhZGRyZXNzICov Ci0tIAoyLjYuMC5yYzIuMjMwLmczZGQxNWMwCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpZMjAzOCBtYWlsaW5nIGxpc3QKWTIwMzhAbGlzdHMubGluYXJv Lm9yZwpodHRwczovL2xpc3RzLmxpbmFyby5vcmcvbWFpbG1hbi9saXN0aW5mby95MjAzOAo=