From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-we0-f172.google.com ([74.125.82.172]:33535 "EHLO mail-we0-f172.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751965AbaFDJE7 convert rfc822-to-8bit (ORCPT ); Wed, 4 Jun 2014 05:04:59 -0400 Received: by mail-we0-f172.google.com with SMTP id k48so8201923wev.3 for ; Wed, 04 Jun 2014 02:04:57 -0700 (PDT) MIME-Version: 1.0 In-Reply-To: <1401812719-25061-1-git-send-email-greearb@candelatech.com> References: <1401812719-25061-1-git-send-email-greearb@candelatech.com> Date: Wed, 4 Jun 2014 11:04:57 +0200 Message-ID: (sfid-20140604_110513_800785_DE728874) Subject: Re: [RFC 1/4] ath10k: provide firmware crash info via debugfs. From: Michal Kazior To: Ben Greear Cc: "ath10k@lists.infradead.org" , linux-wireless Content-Type: text/plain; charset=UTF-8 Sender: linux-wireless-owner@vger.kernel.org List-ID: On 3 June 2014 18:25, wrote: > From: Ben Greear > > Store the firmware crash registers and last 128 or so > firmware debug-log ids and present them to user-space > via debugfs. > > Should help with figuring out why the firmware crashed. > > Signed-off-by: Ben Greear > --- > > This series is compile-tested only at this point. Hoping > for feedback on general approach at least. > > > drivers/net/wireless/ath/ath10k/core.h | 41 +++++++++++ > drivers/net/wireless/ath/ath10k/debug.c | 124 ++++++++++++++++++++++++++++++++ > drivers/net/wireless/ath/ath10k/debug.h | 25 +++++++ > drivers/net/wireless/ath/ath10k/pci.c | 86 +++++++++++++++++++++- > 4 files changed, 273 insertions(+), 3 deletions(-) > > diff --git a/drivers/net/wireless/ath/ath10k/core.h b/drivers/net/wireless/ath/ath10k/core.h > index 68ceef6..4068910 100644 > --- a/drivers/net/wireless/ath/ath10k/core.h > +++ b/drivers/net/wireless/ath/ath10k/core.h > @@ -41,6 +41,8 @@ > #define ATH10K_FLUSH_TIMEOUT_HZ (5*HZ) > #define ATH10K_NUM_CHANS 38 > > +#define REG_DUMP_COUNT_QCA988X 60 /* from pci.h */ I don't like this. [...] > +struct ath10k_tlv_dump_data { > + u32 type; /* see ath10k_fw_error_dump_type above */ > + u32 tlv_len; /* in bytes */ > + u8 tlv_data[]; /* Pad to 32-bit boundaries as needed. */ > +} __packed; > + > +struct ath10k_dump_file_data { > + u32 len; > + u32 magic; /* 0x01020304, tells us byte-order of host if we care */ > + struct ath10k_tlv_dump_data data; /* more may follow */ > +} __packed; > + > +/* This will store at least the last 128 entries. */ > +#define ATH10K_DBGLOG_DATA_LEN (128 * 7 * 4) Where does the 7 and 4 come from? Can't we use sizeof() to compute this? The 128 should probably be a separate #define? [...] > +static struct ath10k_dump_file_data *ath10k_build_dump_file(struct ath10k *ar) > +{ > + unsigned int len = (sizeof(ar->dbglog_entry_data) > + + sizeof(ar->reg_dump_values)); > + unsigned int sofar = 0; > + char *buf; > + struct ath10k_tlv_dump_data *dump_tlv; > + struct ath10k_dump_file_data *dump_data; > + int hdr_len = sizeof(*dump_data) - sizeof(dump_data->data); You call this with conf_mutex held so it's a good idea to have a lockdep here, isn't it? [...] > + /* Gather crash-dump */ > + dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar); > + dump_tlv->type = ATH10K_FW_ERROR_DUMP_REGDUMP; > + dump_tlv->tlv_len = sizeof(ar->reg_dump_values); > + memcpy(dump_tlv->tlv_data, &ar->reg_dump_values, dump_tlv->tlv_len); > + sofar += sizeof(*dump_tlv) + dump_tlv->tlv_len; > + > + return dump_data; > +} > + > + > + > +static int ath10k_fw_error_dump_open(struct inode *inode, struct file *file) 3 newlines? > +{ > + struct ath10k *ar = inode->i_private; > + int ret; > + struct ath10k_dump_file_data *dump; > + > + if (!ar) > + return -EINVAL; > + > + mutex_lock(&ar->conf_mutex); > + > + dump = ath10k_build_dump_file(ar); > + Maybe it's just me, but this newline bugs me :) > + if (!dump) { > + ret = -ENODATA; > + goto out; > + } > + > + file->private_data = dump; > + ar->crashed_since_read = false; > + ret = 0; > + > +out: > + mutex_unlock(&ar->conf_mutex); > + return ret; > +} > + > + > +static ssize_t ath10k_fw_error_dump_read(struct file *file, 2 newlines? [...] > static int ath10k_debug_htt_stats_req(struct ath10k *ar) > { > u64 cookie; > @@ -861,6 +981,9 @@ int ath10k_debug_create(struct ath10k *ar) > debugfs_create_file("simulate_fw_crash", S_IRUSR, ar->debug.debugfs_phy, > ar, &fops_simulate_fw_crash); > > + debugfs_create_file("fw_error_dump", S_IRUSR, ar->debug.debugfs_phy, > + ar, &fops_fw_error_dump); > + > debugfs_create_file("chip_id", S_IRUSR, ar->debug.debugfs_phy, > ar, &fops_chip_id); > > @@ -931,4 +1054,5 @@ void ath10k_dbg_dump(enum ath10k_debug_mask mask, > } > EXPORT_SYMBOL(ath10k_dbg_dump); > > + What is this newline doing here? > #endif /* CONFIG_ATH10K_DEBUG */ > diff --git a/drivers/net/wireless/ath/ath10k/debug.h b/drivers/net/wireless/ath/ath10k/debug.h > index a582499..d9629f9 100644 > --- a/drivers/net/wireless/ath/ath10k/debug.h > +++ b/drivers/net/wireless/ath/ath10k/debug.h > @@ -19,6 +19,7 @@ > #define _DEBUG_H_ > > #include > +#include "pci.h" > #include "trace.h" Not really sure if we should be mixing pci in debug? This actually gets me thinking we could have some stuff in hw.h that isn't really related to the transport. I can imagine usb transport would have pretty much the same hardware at the other side. > enum ath10k_debug_mask { > @@ -110,4 +111,28 @@ static inline void ath10k_dbg_dump(enum ath10k_debug_mask mask, > { > } > #endif /* CONFIG_ATH10K_DEBUG */ > + > + > +/* Target debug log related defines and structs */ > + > +/* Target is 32-bit CPU, so we just use u32 for > + * the pointers. The memory space is relative to the > + * target, not the host. > + */ > +struct dbglog_buf_s { > + u32 next; /* pointer to dblog_buf_s. */ > + u32 buffer; /* pointer to u8 buffer */ > + u32 bufsize; > + u32 length; > + u32 count; > + u32 free; > +} __packed; > + > +struct dbglog_hdr_s { > + u32 dbuf; /* pointer to dbglog_buf_s */ > + u32 dropped; > +} __packed; These structure names look strange. Why the _s suffix? Shouldn't these be called simply ath10k_dbglog_buf and ath10k_dbglog_hdr? Or ath10k_{fw/hw/dev/target}_dbglog_buf/hdr? (In case you want to have a clearer distinction these structures aren't ath10k's per se). [...] > + while (dbufp) { > + struct dbglog_buf_s dbuf; > + > + ret = ath10k_pci_diag_read_mem(ar, dbufp, > + &dbuf, sizeof(dbuf)); > + if (ret != 0) { > + ath10k_err("could not read Debug Log Area: 0x%x\n", > + dbufp); > + goto save_regs_and_restart; > + } > + > + /* We have a buffer of data */ > + /* TODO: Do we need to worry about bit order on some > + * architectures? This seems to work fine with > + * x86-64 host, at least. > + */ ath10k_pci_diag* performs byte-swap so you're good as long as you read word-like data from the target. I suspect this might not work so great if you read something like, say, a mac address which might be stored as a raw byte stream instead. What kind of data can we expect from the dbglog? > + ath10k_err("[%i] next: 0x%x buf: 0x%x sz: %i len: %i count: %i free: %i\n", > + i, dbuf.next, dbuf.buffer, dbuf.bufsize, dbuf.length, > + dbuf.count, dbuf.free); > + if (dbuf.buffer && dbuf.length) { > + u8 *buffer = kmalloc(dbuf.length, GFP_ATOMIC); > + > + if (buffer) { > + ret = ath10k_pci_diag_read_mem(ar, dbuf.buffer, > + buffer, > + dbuf.length); > + if (ret != 0) { > + ath10k_err("could not read Debug Log buffer: 0x%x\n", > + dbuf.buffer); > + kfree(buffer); > + goto save_regs_and_restart; > + } > + > + ath10k_dbg_save_fw_dbg_buffer(ar, buffer, > + dbuf.length); > + kfree(buffer); > + } > + } > + dbufp = dbuf.next; > + if (dbufp == dbg_hdr.dbuf) { > + /* It is a circular buffer it seems, bail if next > + * is head > + */ Hmm, we seem to be mixing comment styles in ath10k now I guess (this applies to other instances of multi-line comments in your patch). What multi-line comment style should we really be using in ath10k? Kalle? Michał From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-wi0-x233.google.com ([2a00:1450:400c:c05::233]) by bombadil.infradead.org with esmtps (Exim 4.80.1 #2 (Red Hat Linux)) id 1Ws78L-0004C3-3C for ath10k@lists.infradead.org; Wed, 04 Jun 2014 09:05:22 +0000 Received: by mail-wi0-f179.google.com with SMTP id bs8so995371wib.12 for ; Wed, 04 Jun 2014 02:04:57 -0700 (PDT) MIME-Version: 1.0 In-Reply-To: <1401812719-25061-1-git-send-email-greearb@candelatech.com> References: <1401812719-25061-1-git-send-email-greearb@candelatech.com> Date: Wed, 4 Jun 2014 11:04:57 +0200 Message-ID: Subject: Re: [RFC 1/4] ath10k: provide firmware crash info via debugfs. From: Michal Kazior List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "ath10k" Errors-To: ath10k-bounces+kvalo=adurom.com@lists.infradead.org To: Ben Greear Cc: linux-wireless , "ath10k@lists.infradead.org" T24gMyBKdW5lIDIwMTQgMTg6MjUsICA8Z3JlZWFyYkBjYW5kZWxhdGVjaC5jb20+IHdyb3RlOgo+ IEZyb206IEJlbiBHcmVlYXIgPGdyZWVhcmJAY2FuZGVsYXRlY2guY29tPgo+Cj4gU3RvcmUgdGhl IGZpcm13YXJlIGNyYXNoIHJlZ2lzdGVycyBhbmQgbGFzdCAxMjggb3Igc28KPiBmaXJtd2FyZSBk ZWJ1Zy1sb2cgaWRzIGFuZCBwcmVzZW50IHRoZW0gdG8gdXNlci1zcGFjZQo+IHZpYSBkZWJ1Z2Zz Lgo+Cj4gU2hvdWxkIGhlbHAgd2l0aCBmaWd1cmluZyBvdXQgd2h5IHRoZSBmaXJtd2FyZSBjcmFz aGVkLgo+Cj4gU2lnbmVkLW9mZi1ieTogQmVuIEdyZWVhciA8Z3JlZWFyYkBjYW5kZWxhdGVjaC5j b20+Cj4gLS0tCj4KPiBUaGlzIHNlcmllcyBpcyBjb21waWxlLXRlc3RlZCBvbmx5IGF0IHRoaXMg cG9pbnQuICBIb3BpbmcKPiBmb3IgZmVlZGJhY2sgb24gZ2VuZXJhbCBhcHByb2FjaCBhdCBsZWFz dC4KPgo+Cj4gZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDEway9jb3JlLmggIHwgIDQxICsr KysrKysrKysrCj4gIGRyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGgxMGsvZGVidWcuYyB8IDEy NCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICBkcml2ZXJzL25ldC93aXJlbGVz cy9hdGgvYXRoMTBrL2RlYnVnLmggfCAgMjUgKysrKysrKwo+ICBkcml2ZXJzL25ldC93aXJlbGVz cy9hdGgvYXRoMTBrL3BjaS5jICAgfCAgODYgKysrKysrKysrKysrKysrKysrKysrLQo+ICA0IGZp bGVzIGNoYW5nZWQsIDI3MyBpbnNlcnRpb25zKCspLCAzIGRlbGV0aW9ucygtKQo+Cj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGgxMGsvY29yZS5oIGIvZHJpdmVycy9u ZXQvd2lyZWxlc3MvYXRoL2F0aDEway9jb3JlLmgKPiBpbmRleCA2OGNlZWY2Li40MDY4OTEwIDEw MDY0NAo+IC0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGgxMGsvY29yZS5oCj4gKysr IGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDEway9jb3JlLmgKPiBAQCAtNDEsNiArNDEs OCBAQAo+ICAjZGVmaW5lIEFUSDEwS19GTFVTSF9USU1FT1VUX0haICg1KkhaKQo+ICAjZGVmaW5l IEFUSDEwS19OVU1fQ0hBTlMgMzgKPgo+ICsjZGVmaW5lIFJFR19EVU1QX0NPVU5UX1FDQTk4OFgg NjAgLyogZnJvbSBwY2kuaCAqLwoKSSBkb24ndCBsaWtlIHRoaXMuCgoKWy4uLl0KPiArc3RydWN0 IGF0aDEwa190bHZfZHVtcF9kYXRhIHsKPiArICAgICAgIHUzMiB0eXBlOyAvKiBzZWUgYXRoMTBr X2Z3X2Vycm9yX2R1bXBfdHlwZSBhYm92ZSAqLwo+ICsgICAgICAgdTMyIHRsdl9sZW47IC8qIGlu IGJ5dGVzICovCj4gKyAgICAgICB1OCB0bHZfZGF0YVtdOyAvKiBQYWQgdG8gMzItYml0IGJvdW5k YXJpZXMgYXMgbmVlZGVkLiAqLwo+ICt9IF9fcGFja2VkOwo+ICsKPiArc3RydWN0IGF0aDEwa19k dW1wX2ZpbGVfZGF0YSB7Cj4gKyAgICAgICB1MzIgbGVuOwo+ICsgICAgICAgdTMyIG1hZ2ljOyAv KiAweDAxMDIwMzA0LCB0ZWxscyB1cyBieXRlLW9yZGVyIG9mIGhvc3QgaWYgd2UgY2FyZSAqLwo+ ICsgICAgICAgc3RydWN0IGF0aDEwa190bHZfZHVtcF9kYXRhIGRhdGE7IC8qIG1vcmUgbWF5IGZv bGxvdyAqLwo+ICt9IF9fcGFja2VkOwo+ICsKPiArLyogVGhpcyB3aWxsIHN0b3JlIGF0IGxlYXN0 IHRoZSBsYXN0IDEyOCBlbnRyaWVzLiAqLwo+ICsjZGVmaW5lIEFUSDEwS19EQkdMT0dfREFUQV9M RU4gKDEyOCAqIDcgKiA0KQoKV2hlcmUgZG9lcyB0aGUgNyBhbmQgNCBjb21lIGZyb20/IENhbid0 IHdlIHVzZSBzaXplb2YoKSB0byBjb21wdXRlIHRoaXM/CgpUaGUgMTI4IHNob3VsZCBwcm9iYWJs eSBiZSBhIHNlcGFyYXRlICNkZWZpbmU/CgpbLi4uXQo+ICtzdGF0aWMgc3RydWN0IGF0aDEwa19k dW1wX2ZpbGVfZGF0YSAqYXRoMTBrX2J1aWxkX2R1bXBfZmlsZShzdHJ1Y3QgYXRoMTBrICphcikK PiArewo+ICsgICAgICAgdW5zaWduZWQgaW50IGxlbiA9IChzaXplb2YoYXItPmRiZ2xvZ19lbnRy eV9kYXRhKQo+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICArIHNpemVvZihhci0+cmVnX2R1 bXBfdmFsdWVzKSk7Cj4gKyAgICAgICB1bnNpZ25lZCBpbnQgc29mYXIgPSAwOwo+ICsgICAgICAg Y2hhciAqYnVmOwo+ICsgICAgICAgc3RydWN0IGF0aDEwa190bHZfZHVtcF9kYXRhICpkdW1wX3Rs djsKPiArICAgICAgIHN0cnVjdCBhdGgxMGtfZHVtcF9maWxlX2RhdGEgKmR1bXBfZGF0YTsKPiAr ICAgICAgIGludCBoZHJfbGVuID0gc2l6ZW9mKCpkdW1wX2RhdGEpIC0gc2l6ZW9mKGR1bXBfZGF0 YS0+ZGF0YSk7CgpZb3UgY2FsbCB0aGlzIHdpdGggY29uZl9tdXRleCBoZWxkIHNvIGl0J3MgYSBn b29kIGlkZWEgdG8gaGF2ZSBhCmxvY2tkZXAgaGVyZSwgaXNuJ3QgaXQ/CgoKWy4uLl0KPiArICAg ICAgIC8qIEdhdGhlciBjcmFzaC1kdW1wICovCj4gKyAgICAgICBkdW1wX3RsdiA9IChzdHJ1Y3Qg YXRoMTBrX3Rsdl9kdW1wX2RhdGEgKikoYnVmICsgc29mYXIpOwo+ICsgICAgICAgZHVtcF90bHYt PnR5cGUgPSBBVEgxMEtfRldfRVJST1JfRFVNUF9SRUdEVU1QOwo+ICsgICAgICAgZHVtcF90bHYt PnRsdl9sZW4gPSBzaXplb2YoYXItPnJlZ19kdW1wX3ZhbHVlcyk7Cj4gKyAgICAgICBtZW1jcHko ZHVtcF90bHYtPnRsdl9kYXRhLCAmYXItPnJlZ19kdW1wX3ZhbHVlcywgZHVtcF90bHYtPnRsdl9s ZW4pOwo+ICsgICAgICAgc29mYXIgKz0gc2l6ZW9mKCpkdW1wX3RsdikgKyBkdW1wX3Rsdi0+dGx2 X2xlbjsKPiArCj4gKyAgICAgICByZXR1cm4gZHVtcF9kYXRhOwo+ICt9Cj4gKwo+ICsKPiArCj4g K3N0YXRpYyBpbnQgYXRoMTBrX2Z3X2Vycm9yX2R1bXBfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2Rl LCBzdHJ1Y3QgZmlsZSAqZmlsZSkKCjMgbmV3bGluZXM/CgoKPiArewo+ICsgICAgICAgc3RydWN0 IGF0aDEwayAqYXIgPSBpbm9kZS0+aV9wcml2YXRlOwo+ICsgICAgICAgaW50IHJldDsKPiArICAg ICAgIHN0cnVjdCBhdGgxMGtfZHVtcF9maWxlX2RhdGEgKmR1bXA7Cj4gKwo+ICsgICAgICAgaWYg KCFhcikKPiArICAgICAgICAgICAgICAgcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsgICAgICAgbXV0 ZXhfbG9jaygmYXItPmNvbmZfbXV0ZXgpOwo+ICsKPiArICAgICAgIGR1bXAgPSBhdGgxMGtfYnVp bGRfZHVtcF9maWxlKGFyKTsKPiArCgpNYXliZSBpdCdzIGp1c3QgbWUsIGJ1dCB0aGlzIG5ld2xp bmUgYnVncyBtZSA6KQoKCj4gKyAgICAgICBpZiAoIWR1bXApIHsKPiArICAgICAgICAgICAgICAg cmV0ID0gLUVOT0RBVEE7Cj4gKyAgICAgICAgICAgICAgIGdvdG8gb3V0Owo+ICsgICAgICAgfQo+ ICsKPiArICAgICAgIGZpbGUtPnByaXZhdGVfZGF0YSA9IGR1bXA7Cj4gKyAgICAgICBhci0+Y3Jh c2hlZF9zaW5jZV9yZWFkID0gZmFsc2U7Cj4gKyAgICAgICByZXQgPSAwOwo+ICsKPiArb3V0Ogo+ ICsgICAgICAgbXV0ZXhfdW5sb2NrKCZhci0+Y29uZl9tdXRleCk7Cj4gKyAgICAgICByZXR1cm4g cmV0Owo+ICt9Cj4gKwo+ICsKPiArc3RhdGljIHNzaXplX3QgYXRoMTBrX2Z3X2Vycm9yX2R1bXBf cmVhZChzdHJ1Y3QgZmlsZSAqZmlsZSwKCjIgbmV3bGluZXM/CgoKWy4uLl0KPiAgc3RhdGljIGlu dCBhdGgxMGtfZGVidWdfaHR0X3N0YXRzX3JlcShzdHJ1Y3QgYXRoMTBrICphcikKPiAgewo+ICAg ICAgICAgdTY0IGNvb2tpZTsKPiBAQCAtODYxLDYgKzk4MSw5IEBAIGludCBhdGgxMGtfZGVidWdf Y3JlYXRlKHN0cnVjdCBhdGgxMGsgKmFyKQo+ICAgICAgICAgZGVidWdmc19jcmVhdGVfZmlsZSgi c2ltdWxhdGVfZndfY3Jhc2giLCBTX0lSVVNSLCBhci0+ZGVidWcuZGVidWdmc19waHksCj4gICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGFyLCAmZm9wc19zaW11bGF0ZV9md19jcmFzaCk7Cj4K PiArICAgICAgIGRlYnVnZnNfY3JlYXRlX2ZpbGUoImZ3X2Vycm9yX2R1bXAiLCBTX0lSVVNSLCBh ci0+ZGVidWcuZGVidWdmc19waHksCj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgIGFyLCAm Zm9wc19md19lcnJvcl9kdW1wKTsKPiArCj4gICAgICAgICBkZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJj aGlwX2lkIiwgU19JUlVTUiwgYXItPmRlYnVnLmRlYnVnZnNfcGh5LAo+ICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBhciwgJmZvcHNfY2hpcF9pZCk7Cj4KPiBAQCAtOTMxLDQgKzEwNTQsNSBA QCB2b2lkIGF0aDEwa19kYmdfZHVtcChlbnVtIGF0aDEwa19kZWJ1Z19tYXNrIG1hc2ssCj4gIH0K PiAgRVhQT1JUX1NZTUJPTChhdGgxMGtfZGJnX2R1bXApOwo+Cj4gKwoKV2hhdCBpcyB0aGlzIG5l d2xpbmUgZG9pbmcgaGVyZT8KCgo+ICAjZW5kaWYgLyogQ09ORklHX0FUSDEwS19ERUJVRyAqLwo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoMTBrL2RlYnVnLmggYi9k cml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoMTBrL2RlYnVnLmgKPiBpbmRleCBhNTgyNDk5Li5k OTYyOWY5IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGgxMGsvZGVi dWcuaAo+ICsrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGgxMGsvZGVidWcuaAo+IEBA IC0xOSw2ICsxOSw3IEBACj4gICNkZWZpbmUgX0RFQlVHX0hfCj4KPiAgI2luY2x1ZGUgPGxpbnV4 L3R5cGVzLmg+Cj4gKyNpbmNsdWRlICJwY2kuaCIKPiAgI2luY2x1ZGUgInRyYWNlLmgiCgpOb3Qg cmVhbGx5IHN1cmUgaWYgd2Ugc2hvdWxkIGJlIG1peGluZyBwY2kgaW4gZGVidWc/CgpUaGlzIGFj dHVhbGx5IGdldHMgbWUgdGhpbmtpbmcgd2UgY291bGQgaGF2ZSBzb21lIHN0dWZmIGluIGh3Lmgg dGhhdAppc24ndCByZWFsbHkgcmVsYXRlZCB0byB0aGUgdHJhbnNwb3J0LiBJIGNhbiBpbWFnaW5l IHVzYiB0cmFuc3BvcnQKd291bGQgaGF2ZSBwcmV0dHkgbXVjaCB0aGUgc2FtZSBoYXJkd2FyZSBh dCB0aGUgb3RoZXIgc2lkZS4KCgo+ICBlbnVtIGF0aDEwa19kZWJ1Z19tYXNrIHsKPiBAQCAtMTEw LDQgKzExMSwyOCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgYXRoMTBrX2RiZ19kdW1wKGVudW0gYXRo MTBrX2RlYnVnX21hc2sgbWFzaywKPiAgewo+ICB9Cj4gICNlbmRpZiAvKiBDT05GSUdfQVRIMTBL X0RFQlVHICovCj4gKwo+ICsKPiArLyogVGFyZ2V0IGRlYnVnIGxvZyByZWxhdGVkIGRlZmluZXMg YW5kIHN0cnVjdHMgKi8KPiArCj4gKy8qIFRhcmdldCBpcyAzMi1iaXQgQ1BVLCBzbyB3ZSBqdXN0 IHVzZSB1MzIgZm9yCj4gKyAqIHRoZSBwb2ludGVycy4gIFRoZSBtZW1vcnkgc3BhY2UgaXMgcmVs YXRpdmUgdG8gdGhlCj4gKyAqIHRhcmdldCwgbm90IHRoZSBob3N0Lgo+ICsgKi8KPiArc3RydWN0 IGRiZ2xvZ19idWZfcyB7Cj4gKyAgICAgICB1MzIgbmV4dDsgLyogcG9pbnRlciB0byBkYmxvZ19i dWZfcy4gKi8KPiArICAgICAgIHUzMiBidWZmZXI7IC8qIHBvaW50ZXIgdG8gdTggYnVmZmVyICov Cj4gKyAgICAgICB1MzIgYnVmc2l6ZTsKPiArICAgICAgIHUzMiBsZW5ndGg7Cj4gKyAgICAgICB1 MzIgY291bnQ7Cj4gKyAgICAgICB1MzIgZnJlZTsKPiArfSBfX3BhY2tlZDsKPiArCj4gK3N0cnVj dCBkYmdsb2dfaGRyX3Mgewo+ICsgICAgICAgdTMyIGRidWY7IC8qIHBvaW50ZXIgdG8gZGJnbG9n X2J1Zl9zICovCj4gKyAgICAgICB1MzIgZHJvcHBlZDsKPiArfSBfX3BhY2tlZDsKClRoZXNlIHN0 cnVjdHVyZSBuYW1lcyBsb29rIHN0cmFuZ2UuIFdoeSB0aGUgX3Mgc3VmZml4PyBTaG91bGRuJ3Qg dGhlc2UKYmUgY2FsbGVkIHNpbXBseSBhdGgxMGtfZGJnbG9nX2J1ZiBhbmQgYXRoMTBrX2RiZ2xv Z19oZHI/IE9yCmF0aDEwa197ZncvaHcvZGV2L3RhcmdldH1fZGJnbG9nX2J1Zi9oZHI/IChJbiBj YXNlIHlvdSB3YW50IHRvIGhhdmUgYQpjbGVhcmVyIGRpc3RpbmN0aW9uIHRoZXNlIHN0cnVjdHVy ZXMgYXJlbid0IGF0aDEwaydzIHBlciBzZSkuCgoKWy4uLl0KPiArICAgICAgIHdoaWxlIChkYnVm cCkgewo+ICsgICAgICAgICAgICAgICBzdHJ1Y3QgZGJnbG9nX2J1Zl9zIGRidWY7Cj4gKwo+ICsg ICAgICAgICAgICAgICByZXQgPSBhdGgxMGtfcGNpX2RpYWdfcmVhZF9tZW0oYXIsIGRidWZwLAo+ ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJmRidWYsIHNp emVvZihkYnVmKSk7Cj4gKyAgICAgICAgICAgICAgIGlmIChyZXQgIT0gMCkgewo+ICsgICAgICAg ICAgICAgICAgICAgICAgIGF0aDEwa19lcnIoImNvdWxkIG5vdCByZWFkIERlYnVnIExvZyBBcmVh OiAweCV4XG4iLAo+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGJ1ZnApOwo+ ICsgICAgICAgICAgICAgICAgICAgICAgIGdvdG8gc2F2ZV9yZWdzX2FuZF9yZXN0YXJ0Owo+ICsg ICAgICAgICAgICAgICB9Cj4gKwo+ICsgICAgICAgICAgICAgICAvKiBXZSBoYXZlIGEgYnVmZmVy IG9mIGRhdGEgKi8KPiArICAgICAgICAgICAgICAgLyogVE9ETzogIERvIHdlIG5lZWQgdG8gd29y cnkgYWJvdXQgYml0IG9yZGVyIG9uIHNvbWUKPiArICAgICAgICAgICAgICAgICogYXJjaGl0ZWN0 dXJlcz8gIFRoaXMgc2VlbXMgdG8gd29yayBmaW5lIHdpdGgKPiArICAgICAgICAgICAgICAgICog eDg2LTY0IGhvc3QsIGF0IGxlYXN0Lgo+ICsgICAgICAgICAgICAgICAgKi8KCmF0aDEwa19wY2lf ZGlhZyogcGVyZm9ybXMgYnl0ZS1zd2FwIHNvIHlvdSdyZSBnb29kIGFzIGxvbmcgYXMgeW91IHJl YWQKd29yZC1saWtlIGRhdGEgZnJvbSB0aGUgdGFyZ2V0LiBJIHN1c3BlY3QgdGhpcyBtaWdodCBu b3Qgd29yayBzbyBncmVhdAppZiB5b3UgcmVhZCBzb21ldGhpbmcgbGlrZSwgc2F5LCBhIG1hYyBh ZGRyZXNzIHdoaWNoIG1pZ2h0IGJlIHN0b3JlZAphcyBhIHJhdyBieXRlIHN0cmVhbSBpbnN0ZWFk LgoKV2hhdCBraW5kIG9mIGRhdGEgY2FuIHdlIGV4cGVjdCBmcm9tIHRoZSBkYmdsb2c/CgoKPiAr ICAgICAgICAgICAgICAgYXRoMTBrX2VycigiWyVpXSBuZXh0OiAweCV4IGJ1ZjogMHgleCBzejog JWkgbGVuOiAlaSBjb3VudDogJWkgZnJlZTogJWlcbiIsCj4gKyAgICAgICAgICAgICAgICAgICAg ICAgICAgaSwgZGJ1Zi5uZXh0LCBkYnVmLmJ1ZmZlciwgZGJ1Zi5idWZzaXplLCBkYnVmLmxlbmd0 aCwKPiArICAgICAgICAgICAgICAgICAgICAgICAgICBkYnVmLmNvdW50LCBkYnVmLmZyZWUpOwo+ ICsgICAgICAgICAgICAgICBpZiAoZGJ1Zi5idWZmZXIgJiYgZGJ1Zi5sZW5ndGgpIHsKPiArICAg ICAgICAgICAgICAgICAgICAgICB1OCAqYnVmZmVyID0ga21hbGxvYyhkYnVmLmxlbmd0aCwgR0ZQ X0FUT01JQyk7Cj4gKwo+ICsgICAgICAgICAgICAgICAgICAgICAgIGlmIChidWZmZXIpIHsKPiAr ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldCA9IGF0aDEwa19wY2lfZGlhZ19yZWFk X21lbShhciwgZGJ1Zi5idWZmZXIsCj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnVmZmVyLAo+ICsgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRidWYubGVuZ3Ro KTsKPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmIChyZXQgIT0gMCkgewo+ICsg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhdGgxMGtfZXJyKCJjb3VsZCBu b3QgcmVhZCBEZWJ1ZyBMb2cgYnVmZmVyOiAweCV4XG4iLAo+ICsgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRidWYuYnVmZmVyKTsKPiArICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAga2ZyZWUoYnVmZmVyKTsKPiArICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ290byBzYXZlX3JlZ3NfYW5kX3Jlc3RhcnQ7 Cj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9Cj4gKwo+ICsgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgYXRoMTBrX2RiZ19zYXZlX2Z3X2RiZ19idWZmZXIoYXIsIGJ1ZmZl ciwKPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGRidWYubGVuZ3RoKTsKPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGtmcmVlKGJ1ZmZlcik7Cj4gKyAgICAgICAgICAgICAgICAgICAgICAgfQo+ICsgICAgICAgICAg ICAgICB9Cj4gKyAgICAgICAgICAgICAgIGRidWZwID0gZGJ1Zi5uZXh0Owo+ICsgICAgICAgICAg ICAgICBpZiAoZGJ1ZnAgPT0gZGJnX2hkci5kYnVmKSB7Cj4gKyAgICAgICAgICAgICAgICAgICAg ICAgLyogSXQgaXMgYSBjaXJjdWxhciBidWZmZXIgaXQgc2VlbXMsIGJhaWwgaWYgbmV4dAo+ICsg ICAgICAgICAgICAgICAgICAgICAgICAqIGlzIGhlYWQKPiArICAgICAgICAgICAgICAgICAgICAg ICAgKi8KCkhtbSwgd2Ugc2VlbSB0byBiZSBtaXhpbmcgY29tbWVudCBzdHlsZXMgaW4gYXRoMTBr IG5vdyBJIGd1ZXNzICh0aGlzCmFwcGxpZXMgdG8gb3RoZXIgaW5zdGFuY2VzIG9mIG11bHRpLWxp bmUgY29tbWVudHMgaW4geW91ciBwYXRjaCkuIFdoYXQKbXVsdGktbGluZSBjb21tZW50IHN0eWxl IHNob3VsZCB3ZSByZWFsbHkgYmUgdXNpbmcgaW4gYXRoMTBrPyBLYWxsZT8KCgpNaWNoYcWCCgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwphdGgxMGsgbWFp bGluZyBsaXN0CmF0aDEwa0BsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRl YWQub3JnL21haWxtYW4vbGlzdGluZm8vYXRoMTBrCg==