Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1rdYQp-006C9Q-QE for pgsql-hackers@arkaria.postgresql.org; Fri, 23 Feb 2024 16:29:52 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.94.2) (envelope-from ) id 1rdYQo-002G2N-3K for pgsql-hackers@arkaria.postgresql.org; Fri, 23 Feb 2024 16:29:50 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1rdYQn-002G2B-KU for pgsql-hackers@lists.postgresql.org; Fri, 23 Feb 2024 16:29:50 +0000 Received: from mail-ed1-x535.google.com ([2a00:1450:4864:20::535]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.94.2) (envelope-from ) id 1rdYQj-000Xz9-I7 for pgsql-hackers@lists.postgresql.org; Fri, 23 Feb 2024 16:29:49 +0000 Received: by mail-ed1-x535.google.com with SMTP id 4fb4d7f45d1cf-5658082d2c4so842409a12.1 for ; Fri, 23 Feb 2024 08:29:44 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=enterprisedb.com; s=google; t=1708705784; x=1709310584; darn=lists.postgresql.org; h=in-reply-to:from:content-language:references:cc:to:subject :user-agent:mime-version:date:message-id:from:to:cc:subject:date :message-id:reply-to; bh=MP1IFETHP5OTY4dGABs7eANjG7k7Xquwj8qL8SeKsrI=; b=NDuqj1duEAKECRWcYGYWO0S9kTqUtAoZGmzSjNcWmU5q9RSAqNLHgXZ8kGpfcMBIoM Wpjnf+wuqNY3y/29tRDu9x2EbQaAC1b9RKyEoYNv2hHNKu0DfKj3J40eOrsEPRmCIL0j FErMSThCWPSeYd3vAsjoyRuYBlya91QIZ7HD7DrUriBCMGBM8msABOVEeL6Un2bDCD4k V6QC0MhxDCckFKFricZFpCzp3cv/ZjQTFsrfcsTkv5tOWrxAnLvxpwyPeZCoTFshufPY 3AqsvwQAs9tHzfmE/sifEtqwuMQb+wA2KHcggXBTXnYdt2fLOsboy5Ng+l/KWObTUZSP ZKGQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1708705784; x=1709310584; h=in-reply-to:from:content-language:references:cc:to:subject :user-agent:mime-version:date:message-id:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=MP1IFETHP5OTY4dGABs7eANjG7k7Xquwj8qL8SeKsrI=; b=J81T4ba+Nws1UPegKmV1hPl9lgSvKnOd/V/AYDZN0tHe1GW+cx8hGlu31SgE9fK2Ah JToyHt1HhNYrq2BheXOQeDOum/TKt+gQgWBrJ64CBuIc9CDUcIqD+JgyS8h6ZifQjY0r Gf5BlDZyLEJ8IBjf6oZp9h7VrP+VXNZvhp8TU6HFcMNVpoUzgNv5A6JXUzH69Jm4XjRR NAuGLmgbyeuKNQVkFWuhHIa1Ug0vV/e+0zD8G9056o0XD5DviMR9hVCr+9lUe2AhExqb 0VyI2HKHBj0d6wqEUPiRey8RZ3AlV5HbBD0g9WlCDRoKzpiFddDZRmLmPIATjXi2Ep44 r3+g== X-Forwarded-Encrypted: i=1; AJvYcCWI6F7D0+2C0YGIda89JPA161T7Xhh4KFA2tVAOG76dNNvJqXNzP+3vOKhOnEpry/UN9sLDEqpRZ2iAVCMx2TZxWgJ0lhSN1DWRDRHsbYgMnlo8 X-Gm-Message-State: AOJu0YyOkIua2PB8NP1UjOch2Pnf97mGQOVpVPW9t79SQC3BZnz4W4k6 BEbVEr7gQL5wXFqxwvRb7Eg2CYWcjGcUmX8pLGwFDaWc/55T7NX2ykrWSJHrcn0DSY9RAjZABag = X-Google-Smtp-Source: AGHT+IEtEs9j2uQU2DOkhYbjV617Zzogx8cJAwSvsP8EB/6iSZUZ7ArPtEDh8FjE1XWk9zycD5SCtg== X-Received: by 2002:a05:6402:1607:b0:565:7d4a:1d4c with SMTP id f7-20020a056402160700b005657d4a1d4cmr218722edv.9.1708705783592; Fri, 23 Feb 2024 08:29:43 -0800 (PST) Received: from [10.137.0.18] (ip-86-49-229-30.bb.vodafone.cz. [86.49.229.30]) by smtp.gmail.com with ESMTPSA id dh18-20020a0564021d3200b0056176e95a88sm6548421edb.32.2024.02.23.08.29.42 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Fri, 23 Feb 2024 08:29:42 -0800 (PST) Content-Type: multipart/mixed; boundary="------------9aa4PS6RDhvp5jfrDfxgDS8r" Message-ID: <23e03725-8c77-431d-9f53-51709260ffeb@enterprisedb.com> Date: Fri, 23 Feb 2024 17:29:38 +0100 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: Improve eviction algorithm in ReorderBuffer To: vignesh C , Masahiko Sawada Cc: "Hayato Kuroda (Fujitsu)" , Shubham Khanna , Amit Kapila , Dilip Kumar , PostgreSQL Hackers References: Content-Language: en-US From: Tomas Vondra In-Reply-To: List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk This is a multi-part message in MIME format. --------------9aa4PS6RDhvp5jfrDfxgDS8r Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit Hi, I did a basic review and testing of this patch today. Overall I think the patch is in very good shape - I agree with the tradeoffs it makes, and I like the approach in general. I do have a couple minor comments about the code, and then maybe a couple thoughts about the approach. First, some comments - I'll put them here, but I also kept them in "review" commits, because that makes it easier to show the exact place in the code the comment is about. 1) binaryheap_allocate got a new "indexed" argument, but the comment is not updated to document it 2) I think it's preferable to use descriptive argument names for bh_set_node. I don't think there's a good reason to keep it short. 3) In a couple places we have code like this: if (heap->bh_indexed) bh_nodeidx_delete(heap->bh_nodeidx, result); Maybe it'd be better to have the if condition in bh_nodeidx_delete, so that it can be called without it. 4) Could we check the "found" flag in bh_set_node, somehow? I mean, we either expect to find the node (update of already tracked transaction) or not (when inserting it). The life cycle may be non-trivial (node added, updated and removed, ...), would be useful assert I think. 5) Do we actually need the various mem_freed local variables in a couple places, when we expect the value to be equal to txn->size (there's even assert enforcing that)? 6) ReorderBufferCleanupTXN has a comment about maybe not using the same threshold both to enable & disable usage of the binaryheap. I agree with that, otherwise we could easily end up "trashing" if we add/remove transactions right around the threshold. I think 90-95% for disabling the heap would work fine. 7) The code disabling binaryheap (based on the threshold) is copied in a couple places, perhaps it should be a separate function called from those places. 8) Similarly to (3), maybe ReorderBufferTXNMemoryUpdate should do the memory size check internally, to make the calls simpler. 9) The ReorderBufferChangeMemoryUpdate / ReorderBufferTXNMemoryUpdate split maybe not very clear. It's not clear to me why it's divided like this, or why we can't simply call ReorderBufferTXNMemoryUpdate directly. performance ----------- I did some benchmarks, to see the behavior in simple good/bad cases (see the attached scripts.tgz). "large" is one large transaction inserting 1M rows, small is 64k single-row inserts, and subxacts is the original case with ~100k subxacts. Finally, subxacts-small is many transactions with 128 subxacts each (the main transactions are concurrent). The results are pretty good, I think: test master patched ----------------------------------------------------- large 2587 2459 95% small 956 856 89% subxacts 138915 2911 2% subxacts-small 13632 13187 97% This is timing (ms) with logical_work_mem=4MB. I also tried with 64MB, where the subxact timing goes way down, but the overall conclusions do not change. I was a bit surprised I haven't seen any clear regression, but in the end that's a good thing, right? There's a couple results in this thread showing ~10% regression, but I've been unable to reproduce those. Perhaps the newer patch versions fix that, I guess. Anyway, I think that at some point we'd have to accept that some cases may have slight regression. I think that's inherent for almost any heuristics - there's always going to be some rare case that defeats it. What's important is that the case needs to be rare and/or the impact very limited. And I think that's true here. overall design -------------- As for the design, I agree with the approach of using a binaryheap to track transactions by size. When going over the thread history, describing the initial approach with only keeping "large" transactions above some threshold (e.g. 10%), I was really concerned that'll either lead to abrupt changes in behavior (when transactions move just around the 10%), or won't help with many common cases (with most transactions being below the limit). I was going to suggest some sort of "binning" - keeping lists for transactions of similar size (e.g. <1kB, 1-2kB, 2-4kB, 4-8kB, ...) and evicting transactions from a list, i.e. based on approximate size. But if the indexed binary heap seems to be cheap enough, I think it's a better solution. The one thing I'm a bit concerned about is the threshold used to start using binary heap - these thresholds with binary decisions may easily lead to a "cliff" and robustness issues, i.e. abrupt change in behavior with significant runtime change (e.g. you add/remove one transaction and the code takes a much more expensive path). The value (1024) seems rather arbitrary, I wonder if there's something to justify that choice. In any case, I agree it'd be good to have some dampening factor, to reduce the risk of trashing because of adding/removing a single transaction to the decoding. related stuff / GenerationContext --------------------------------- It's not the fault of this patch, but this reminds me I have some doubts about how the eviction interferes with using the GenerationContext for some of the data. I suspect we can easily get into a situation where we evict the largest transaction, but that doesn't actually reduce the memory usage at all, because the memory context blocks are shared with some other transactions and don't get 100% empty (so we can't release them). But it's actually worse, because GenerationContext does not even reuse this memory. So do we even gain anything by the eviction? When the earlier patch versions also considered age of the transaction, to try evicting the older ones first, I think that was interesting. I think we may want to do something like this even with the binary heap. related stuff / increase of logical_decoding_work_mem ----------------------------------------------------- In the thread, one of the "alternatives to spilling" suggested in the thread was to enable streaming, but I think there's often a much more efficient alternative - increase the amount of memory, so that we don't actually need to spill. For example, a system may be doing a lot of eviction / spilling with logical_decoding_work_mem=64MB, but setting 128MB may completely eliminate that. Of course, if there are large transactions, this may not be possible (the GUC would have to exceed RAM). But I don't think that's very common, the incidents that I've observed were often resolved by bumping the logical_decoding_work_mem by a little bit. I wonder if there's something we might do to help users to tune this. We should be able to measure the "peak" memory usage (how much memory we'd need to not spill), so maybe we could log that as a WARNING, similarly to checkpoints - there we only log "checkpoints too frequent, tune WAL limits", but perhaps we might do more here? Or maybe we could add the watermark to the system catalog? regards -- Tomas Vondra EnterpriseDB: http://www.enterprisedb.com The Enterprise PostgreSQL Company --------------9aa4PS6RDhvp5jfrDfxgDS8r Content-Type: text/x-patch; charset=UTF-8; name="v5-0005-review.patch" Content-Disposition: attachment; filename="v5-0005-review.patch" Content-Transfer-Encoding: base64 RnJvbSA2ZGZlYjYxZmZkZGVlZGM4ZTAwZjhkZTVlYjZiNjQ0YjI4YWUxZjYyIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb21hcyBWb25kcmEgPHRvbWFzQDJuZHF1YWRyYW50 LmNvbT4KRGF0ZTogRnJpLCAyMyBGZWIgMjAyNCAxMzoxNTo0NCArMDEwMApTdWJqZWN0OiBb UEFUQ0ggdjUgNS81XSByZXZpZXcKCi0tLQogLi4uL3JlcGxpY2F0aW9uL2xvZ2ljYWwvcmVv cmRlcmJ1ZmZlci5jICAgICAgIHwgMzIgKysrKysrKysrKysrLS0tLS0tLQogMSBmaWxlIGNo YW5nZWQsIDIxIGluc2VydGlvbnMoKyksIDExIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBh L3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvcmVvcmRlcmJ1ZmZlci5jIGIvc3Jj L2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC9yZW9yZGVyYnVmZmVyLmMKaW5kZXggZjIy Y2YyZmI5YjguLjQwZmEyYmE5ODQzIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9yZXBsaWNh dGlvbi9sb2dpY2FsL3Jlb3JkZXJidWZmZXIuYworKysgYi9zcmMvYmFja2VuZC9yZXBsaWNh dGlvbi9sb2dpY2FsL3Jlb3JkZXJidWZmZXIuYwpAQCAtMTUzNyw3ICsxNTM3LDcgQEAgUmVv cmRlckJ1ZmZlckNsZWFudXBUWE4oUmVvcmRlckJ1ZmZlciAqcmIsIFJlb3JkZXJCdWZmZXJU WE4gKnR4bikKIHsKIAlib29sCQlmb3VuZDsKIAlkbGlzdF9tdXRhYmxlX2l0ZXIgaXRlcjsK LQlTaXplCQltZW1fZnJlZWQgPSAwOworCVNpemUJCW1lbV9mcmVlZCA9IDA7CS8qIFhYWCB3 aHkgZG9uJ3Qgd2UgdXNlIHR4bi0+c2l6ZSBkaXJlY3RseT8gKi8KIAogCS8qIGNsZWFudXAg c3VidHJhbnNhY3Rpb25zICYgdGhlaXIgY2hhbmdlcyAqLwogCWRsaXN0X2ZvcmVhY2hfbW9k aWZ5KGl0ZXIsICZ0eG4tPnN1YnR4bnMpCkBAIC0xNTcxLDExICsxNTcxLDYgQEAgUmVvcmRl ckJ1ZmZlckNsZWFudXBUWE4oUmVvcmRlckJ1ZmZlciAqcmIsIFJlb3JkZXJCdWZmZXJUWE4g KnR4bikKIAkJUmVvcmRlckJ1ZmZlclJldHVybkNoYW5nZShyYiwgY2hhbmdlLCBmYWxzZSk7 CiAJfQogCi0JLyogVXBkYXRlIHRoZSBtZW1vcnkgY291bnRlciAqLwotCUFzc2VydChtZW1f ZnJlZWQgPT0gdHhuLT5zaXplKTsKLQlpZiAobWVtX2ZyZWVkID4gMCkKLQkJUmVvcmRlckJ1 ZmZlclRYTk1lbW9yeVVwZGF0ZShyYiwgdHhuLCBmYWxzZSwgbWVtX2ZyZWVkKTsKLQogCS8q CiAJICogQ2xlYW51cCB0aGUgdHVwbGVjaWRzIHdlIHN0b3JlZCBmb3IgZGVjb2RpbmcgY2F0 YWxvZyBzbmFwc2hvdCBhY2Nlc3MuCiAJICogVGhleSBhcmUgYWx3YXlzIHN0b3JlZCBpbiB0 aGUgdG9wbGV2ZWwgdHJhbnNhY3Rpb24uCkBAIC0xNjM1LDE0ICsxNjMwLDIxIEBAIFJlb3Jk ZXJCdWZmZXJDbGVhbnVwVFhOKFJlb3JkZXJCdWZmZXIgKnJiLCBSZW9yZGVyQnVmZmVyVFhO ICp0eG4pCiAJLyogZGVhbGxvY2F0ZSAqLwogCVJlb3JkZXJCdWZmZXJSZXR1cm5UWE4ocmIs IHR4bik7CiAKKwkvKiBVcGRhdGUgdGhlIG1lbW9yeSBjb3VudGVyICovCisJQXNzZXJ0KG1l bV9mcmVlZCA9PSB0eG4tPnNpemUpOworCVJlb3JkZXJCdWZmZXJUWE5NZW1vcnlVcGRhdGUo cmIsIHR4biwgZmFsc2UsIG1lbV9mcmVlZCk7CisKIAkvKgotCSAqIENoZWNrIGlmIHRoZSBu dW1iZXIgb2YgdHJhbnNhY3Rpb25zIGdldCBsb3dlciB0aGFuIHRoZSB0aHJlc2hvbGQuIElm CisJICogQ2hlY2sgaWYgdGhlIG51bWJlciBvZiB0cmFuc2FjdGlvbnMgZ290IGxvd2VyIHRo YW4gdGhlIHRocmVzaG9sZC4gSWYKIAkgKiBzbywgc3dpdGNoIHRvIE5PX01BWEhFQVAgc3Rh dGUgYW5kIHJlc2V0IHRoZSBtYXgtaGVhcC4KIAkgKgotCSAqIFhYWDogSWYgYSBuZXcgdHJh bnNhY3Rpb24gaXMgYWRkZWQgYW5kIHRoZSBtZW1vcnkgdXNhZ2UgcmVhY2hlZCB0aGUKKwkg KiBYWFg6IElmIGEgbmV3IHRyYW5zYWN0aW9uIGlzIGFkZGVkIGFuZCB0aGUgbWVtb3J5IHVz YWdlIHJlYWNoZXMgdGhlCiAJICogbGltaXQgc29vbiwgd2Ugd2lsbCBlbmQgdXAgYnVpbGRp bmcgdGhlIG1heC1oZWFwIGFnYWluLiBJdCBtaWdodCBiZQogCSAqIG1vcmUgZWZmaWNpZW50 IGlmIHdlIGFjY2VwdCBhIGNlcnRhaW4gYW1vdW50IG9mIHRyYW5zYWN0aW9ucyB0byBzd2l0 Y2gKIAkgKiBiYWNrIHRvIHRoZSBOT19NQVhIRUFQIHN0YXRlLCBzYXkgOTUlIG9mIHRoZSB0 aHJlc2hvbGQuCisJICoKKwkgKiBYWFggWWVzLCBoYXZpbmcgdGhlIGVuYWJsZS9kaXNhYmxl IHRocmVzaG9sZCBleGFjdGx5IHRoZSBzYW1lIGNhbiBsZWFkCisJICogdG8gdHJhc2hpbmcu IFNvbWV0aGluZyBsaWtlIDkwJSB3b3VsZCB3b3JrLCBJIHRoaW5rLgogCSAqLwogCWlmIChy Yi0+bWVtdHJhY2tfc3RhdGUgPT0gUkVPUkRFUl9CVUZGRVJfTUVNX1RSQUNLX01BSU5UQUlO X01BWEhFQVAgJiYKIAkJKGJpbmFyeWhlYXBfc2l6ZShyYi0+dHhuX2hlYXApIDwgUkVPUkRF Ul9CVUZGRVJfTUVNX1RSQUNLX1RIUkVTSE9MRCkpCkBAIC0zMjU3LDYgKzMyNTksMTAgQEAg UmVvcmRlckJ1ZmZlckNoYW5nZU1lbW9yeVVwZGF0ZShSZW9yZGVyQnVmZmVyICpyYiwKICAq IGNvdW50ZXJzIGluc3RlYWQgLSB3ZSBkb24ndCByZWFsbHkgY2FyZSBhYm91dCBzdWJ0cmFu c2FjdGlvbnMgYXMgd2UKICAqIGNhbid0IHN0cmVhbSB0aGVtIGluZGl2aWR1YWxseSBhbnl3 YXksIGFuZCB3ZSBvbmx5IHBpY2sgdG9wbGV2ZWwKICAqIHRyYW5zYWN0aW9ucyBmb3IgZXZp Y3Rpb24uIFNvIG9ubHkgdG9wbGV2ZWwgdHJhbnNhY3Rpb25zIG1hdHRlci4KKyAqCisgKiBY WFggTm90IHN1cmUgdGhlIG5hbWluZyBpcyBncmVhdCwgaXQgc2VlbXMgcHJldHR5IHNpbWls YXIgdG8gdGhlIGVhcmxpZXIKKyAqIGZ1bmN0aW9uLCBjYW4gYmUgcXVpdGUgY29uZnVzaW5n LiBXaHkgZG8gd2UgZXZlbiBuZWVkIHRoZSBzZXBhcmF0ZSBmdW5jdGlvbgorICogYW5kIGNh bid0IHNpbXBseSBjYWxsIFJlb3JkZXJCdWZmZXJDaGFuZ2VNZW1vcnlVcGRhdGUgZnJvbSBl dmVyeXdoZXJlPwogICovCiBzdGF0aWMgdm9pZAogUmVvcmRlckJ1ZmZlclRYTk1lbW9yeVVw ZGF0ZShSZW9yZGVyQnVmZmVyICpyYiwgUmVvcmRlckJ1ZmZlclRYTiAqdHhuLApAQCAtMzI2 NCw2ICszMjcwLDkgQEAgUmVvcmRlckJ1ZmZlclRYTk1lbW9yeVVwZGF0ZShSZW9yZGVyQnVm ZmVyICpyYiwgUmVvcmRlckJ1ZmZlclRYTiAqdHhuLAogewogCVJlb3JkZXJCdWZmZXJUWE4g KnRvcHR4bjsKIAorCWlmIChzeiA9PSAwKQorCQlyZXR1cm47CisKIAkvKgogCSAqIFVwZGF0 ZSB0aGUgdG90YWwgc2l6ZSBpbiB0b3AgbGV2ZWwgYXMgd2VsbC4gVGhpcyBpcyBsYXRlciB1 c2VkIHRvCiAJICogY29tcHV0ZSB0aGUgZGVjb2Rpbmcgc3RhdHMuCkBAIC0zNzQ1LDYgKzM3 NTQsOCBAQCBSZW9yZGVyQnVmZmVyQ2hlY2tNZW1vcnlMaW1pdChSZW9yZGVyQnVmZmVyICpy YikKIAkgKiBDaGVjayB0aGUgbnVtYmVyIG9mIHRyYW5zYWN0aW9ucyBpbiBtYXgtaGVhcCBh ZnRlciBldmljdGluZyBsYXJnZQogCSAqIHRyYW5zYWN0aW9ucy4gSWYgdGhlIG51bWJlciBv ZiB0cmFuc2FjdGlvbnMgaXMgc21hbGwsIHdlIHN3aXRjaCBiYWNrCiAJICogdG8gdGhlIE5P X01BWEhFQVAgc3RhdGUsIGFuZCByZXNldCB0aGUgY3VycmVudCB0aGUgbWF4LWhlYXAuCisJ ICoKKwkgKiBYWFggV2UgYWxyZWFkeSBoYXZlIHRoaXMgYmxvY2sgZWxzZXdoZXJlLCBtYXli ZSBoYXZlIGEgZnVuY3Rpb24/CiAJICovCiAJaWYgKHJiLT5tZW10cmFja19zdGF0ZSA9PSBS RU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tfTUFJTlRBSU5fTUFYSEVBUCAmJgogCQkoYmluYXJ5 aGVhcF9zaXplKHJiLT50eG5faGVhcCkgPCBSRU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tfVEhS RVNIT0xEKSkKQEAgLTM3NjksNyArMzc4MCw3IEBAIFJlb3JkZXJCdWZmZXJTZXJpYWxpemVU WE4oUmVvcmRlckJ1ZmZlciAqcmIsIFJlb3JkZXJCdWZmZXJUWE4gKnR4bikKIAlYTG9nU2Vn Tm8JY3VyT3BlblNlZ05vID0gMDsKIAlTaXplCQlzcGlsbGVkID0gMDsKIAlTaXplCQlzaXpl ID0gdHhuLT5zaXplOwotCVNpemUJCW1lbV9mcmVlZCA9IDA7CisJU2l6ZQkJbWVtX2ZyZWVk ID0gMDsJLyogWFhYIHdoeSBuZWVkZWQ/IGNhbid0IHdlIGp1c3QgdXNlIHR4bi0+c2l6ZT8g Ki8KIAogCWVsb2coREVCVUcyLCAic3BpbGwgJXUgY2hhbmdlcyBpbiBYSUQgJXUgdG8gZGlz ayIsCiAJCSAodWludDMyKSB0eG4tPm5lbnRyaWVzX21lbSwgdHhuLT54aWQpOwpAQCAtMzgz MSw4ICszODQyLDcgQEAgUmVvcmRlckJ1ZmZlclNlcmlhbGl6ZVRYTihSZW9yZGVyQnVmZmVy ICpyYiwgUmVvcmRlckJ1ZmZlclRYTiAqdHhuKQogCiAJLyogVXBkYXRlIHRoZSBtZW1vcnkg Y291bnRlciAqLwogCUFzc2VydChtZW1fZnJlZWQgPT0gdHhuLT5zaXplKTsKLQlpZiAobWVt X2ZyZWVkID4gMCkKLQkJUmVvcmRlckJ1ZmZlclRYTk1lbW9yeVVwZGF0ZShyYiwgdHhuLCBm YWxzZSwgbWVtX2ZyZWVkKTsKKwlSZW9yZGVyQnVmZmVyVFhOTWVtb3J5VXBkYXRlKHJiLCB0 eG4sIGZhbHNlLCBtZW1fZnJlZWQpOwogCiAJLyogdXBkYXRlIHRoZSBzdGF0aXN0aWNzIGlm ZiB3ZSBoYXZlIHNwaWxsZWQgYW55dGhpbmcgKi8KIAlpZiAoc3BpbGxlZCkKLS0gCjIuNDMu MAoK --------------9aa4PS6RDhvp5jfrDfxgDS8r Content-Type: text/x-patch; charset=UTF-8; name="v5-0004-Use-max-heap-to-evict-largest-transactions-in-Reo.patch" Content-Disposition: attachment; filename*0="v5-0004-Use-max-heap-to-evict-largest-transactions-in-Reo.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSA4ODlkMGRjM2EzZmYyMDNmZDM4MmU1MDIwMDI5YTc4YjkzMzRjNTg2IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYXNhaGlrbyBTYXdhZGEgPHNhd2FkYS5tc2hrQGdt YWlsLmNvbT4KRGF0ZTogRnJpLCAyNiBKYW4gMjAyNCAxMTozMTo0MSArMDkwMApTdWJqZWN0 OiBbUEFUQ0ggdjUgNC81XSBVc2UgbWF4LWhlYXAgdG8gZXZpY3QgbGFyZ2VzdCB0cmFuc2Fj dGlvbnMgaW4KIFJlb3JkZXJCdWZmZXIuCgpQcmV2aW91c2x5LCB3aGVuIHNlbGVjdGluZyB0 aGUgdHJhbnNhY3Rpb24gdG8gZXZpY3QsIHdlIGNoZWNrIGFsbAp0cmFuc2FjdGlvbnMgdG8g ZmluZCB0aGUgbGFyZ2VzdCB0cmFuc2FjdGlvbi4gV2hpY2ggY291bGQgbGVhZCB0byBhCnNp Z25pZmljYW50IHJlcGxpY2F0aW9uIGxhZyBlc3BlY2lhbGx5IGluIGNhc2Ugd2hlcmUgdGhl cmUgYXJlIG1hbnkKc3VidHJhbnNhY3Rpb25zLgoKVGhpcyBjb21taXQgaW1wcm92ZXMgdGhl IGV2aWN0aW9uIGFsZ29yaXRobSBpbiBSZW9yZGVyQnVmZmVyIHVzaW5nIHRoZQptYXgtaGVh cCB3aXRoIHRyYW5zYWN0aW9uIHNpemUgYXMgdGhlIGtleSB0byBmaW5kIHRoZSBsYXJnZXN0 CnRyYW5zYWN0aW9uLiBUaGUgbWF4LWhlYXAgc3RhdGUgaXMgbWFuZWdlZCBpbiB0d28gc3Rh dGVzLgoKT3ZlcmFsbCBhbGdvcml0aG06CgpSRU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tfTk9f TUFYSEVBUCBpcyB0aGUgc3RhcnRpbmcgc3RhdGUsIHdoZXJlIHdlIGRvCm5vdCB1cGRhdGUg dGhlIG1heC1oZWFwIHdoZW4gdXBkYXRpbmcgdGhlIG1lbW9yeSBjb3VudGVyLiBXZSBidWls ZCB0aGUKbWF4LWhlYXAganVzdCBiZWZvcmUgc2VsZWN0aW5nIGxhcmdlIHRyYW5zYWN0aW9u cy4gVGhlcmVmb3JlLCBpbiB0aGlzCnN0YXRlLCB3ZSBjYW4gdXBkYXRlIHRoZSBtZW1vcnkg Y291bnRlciB3aXRoIG5vIGFkZGl0aW9uYWwgY29zdHMgYnV0Cm5lZWQgTyhuKSB0aW1lIHRv IGdldCB0aGUgbGFyZ2VzdCB0cmFuc2FjdGlvbiwgd2hlcmUgbiBpcyB0aGUgbnVtYmVyIG9m CnRyYW5zYWN0aW9ucyBpbmNsdWRpbmcgdG9wLWxldmVsIHRyYW5zYWN0aW9ucyBhbmQgc3Vi dHJhbnNhY3Rpb25zLgoKT25jZSB3ZSBidWlsZCB0aGUgbWF4LWhlYXAsIHdlIHN3aXRjaCB0 bwpSRU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tfTUFJTlRBSU5fTUFYSEVBUCBzdGF0ZSwgd2hl cmUgd2UgYWxzbyB1cGRhdGUKdGhlIG1heC1oZWFwIHdoZW4gdXBkYXRpbmcgdGhlIG1lbW9y eSBjb3VudGVyLiBUaGUgaW50ZW50aW9uIGlzIHRvCmVmZmljaWVudGx5IHJldHJpZXZlIHRo ZSBsYXJnZXN0IHRyYW5zYWN0aW9uIGluIE8oMSkgdGltZSBpbnN0ZWFkIG9mCmluY3Vycmlu ZyB0aGUgY29zdCBvZiBtZW1vcnkgY291bnRlciB1cGRhdGVzIChPKGxvZyBuKSkuIFdlIHJl bWFpbiBpbgp0aGlzIHN0YXRlIGFzIGxvbmcgYXMgdGhlIG51bWJlciBvZiB0cmFuc2FjdGlv bnMgaXMgbGFyZ2VyIHRoYW4gdGhlCnRocmVzaG9sZCwgUkVPUkRFUl9CVUZGRVJfTUVNX1RS QUNLX1RIUkVTSE9MRC4gT3RoZXJ3aXNlLCB3ZSBzd2l0Y2ggYmFjawp0byBSRU9SREVSX0JV RkZFUl9NRU1fVFJBQ0tfTk9fTUFYSEVBUCBhbmQgcmVzZXQgdGhlIG1heC1oZWFwLgoKVGhl IHBlcmZvcm1hbmNlIGJlbmNobWFyayByZXN1bHRzIHNob3dlZCBzaWduaWZpY2FudCBzcGVl ZCB1cCAobW9yZQp0aGFuIHgzMCBzcGVlZCB1cCBvbiBteSBtYWNoaW5lKSBpbiBkZWNvZGlu ZyBhIHRyYW5zYWN0aW9uIHdpdGggMTAwawpzdWJ0cmFuc2FjdGlvbnMsIHdoZXJlYXMgdGhl cmUgaXMgbm8gdmlzaWJsZSBvdmVyaGVhZCBpbiBvdGhlciBjYXNlcy4KClhYWDogdXBkYXRl IHR5cGVkZWYubGlzdAoKQXV0aG9yOgpSZXZpZXdlZC1ieToKRGlzY3Vzc2lvbjogaHR0cHM6 Ly9wb3N0Z3IuZXMvbS8KLS0tCiAuLi4vcmVwbGljYXRpb24vbG9naWNhbC9yZW9yZGVyYnVm ZmVyLmMgICAgICAgfCAxOTcgKysrKysrKysrKysrKysrLS0tCiBzcmMvaW5jbHVkZS9yZXBs aWNhdGlvbi9yZW9yZGVyYnVmZmVyLmggICAgICAgfCAgMjEgKysKIDIgZmlsZXMgY2hhbmdl ZCwgMTg5IGluc2VydGlvbnMoKyksIDI5IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3Ny Yy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvcmVvcmRlcmJ1ZmZlci5jIGIvc3JjL2Jh Y2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC9yZW9yZGVyYnVmZmVyLmMKaW5kZXggOTFiOTYx OGQ3ZWMuLmYyMmNmMmZiOWI4IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9yZXBsaWNhdGlv bi9sb2dpY2FsL3Jlb3JkZXJidWZmZXIuYworKysgYi9zcmMvYmFja2VuZC9yZXBsaWNhdGlv bi9sb2dpY2FsL3Jlb3JkZXJidWZmZXIuYwpAQCAtNjcsNiArNjcsMjYgQEAKICAqCSAgYWxs b2NhdG9yLCBldmljdGluZyB0aGUgb2xkZXN0IGNoYW5nZXMgd291bGQgbWFrZSBpdCBtb3Jl IGxpa2VseSB0aGUKICAqCSAgbWVtb3J5IGdldHMgYWN0dWFsbHkgZnJlZWQuCiAgKgorICoJ ICBXZSB1c2UgYSBtYXgtaGVhcCB3aXRoIHRyYW5zYWN0aW9uIHNpemUgYXMgdGhlIGtleSB0 byBlZmZpY2llbnRseSBmaW5kCisgKgkgIHRoZSBsYXJnZXN0IHRyYW5zYWN0aW9uLiBUaGUg bWF4LWhlYXAgc3RhdGUgaXMgbWFuYWdlZCBpbiB0d28gc3RhdGVzOgorICoJICBSRU9SREVS X0JVRkZFUl9NRU1fVFJBQ0tfTk9fTUFYSEVBUCBhbmQgUkVPUkRFUl9CVUZGRVJfTUVNX1RS QUNLX01BSU5UQUlOX01BWEhFQVAuCisgKgorICoJICBSRU9SREVSX0JVRkZFUl9NRU1fVFJB Q0tfTk9fTUFYSEVBUCBpcyB0aGUgc3RhcnRpbmcgc3RhdGUsIHdoZXJlIHdlIGRvCisgKgkg IG5vdCB1cGRhdGUgdGhlIG1heC1oZWFwIHdoZW4gdXBkYXRpbmcgdGhlIG1lbW9yeSBjb3Vu dGVyLiBXZSBidWlsZCB0aGUKKyAqCSAgbWF4LWhlYXAganVzdCBiZWZvcmUgc2VsZWN0aW5n IGxhcmdlIHRyYW5zYWN0aW9ucy4gVGhlcmVmb3JlLCBpbiB0aGlzCisgKgkgIHN0YXRlLCB3 ZSBjYW4gdXBkYXRlIHRoZSBtZW1vcnkgY291bnRlciB3aXRoIG5vIGFkZGl0aW9uYWwgY29z dHMgYnV0CisgKgkgIG5lZWQgTyhuKSB0aW1lIHRvIGdldCB0aGUgbGFyZ2VzdCB0cmFuc2Fj dGlvbiwgd2hlcmUgbiBpcyB0aGUgbnVtYmVyIG9mCisgKgkgIHRyYW5zYWN0aW9ucyBpbmNs dWRpbmcgdG9wLWxldmVsIHRyYW5zYWN0aW9ucyBhbmQgc3VidHJhbnNhY3Rpb25zLgorICoK KyAqCSAgT25jZSB3ZSBidWlsZCB0aGUgbWF4LWhlYXAsIHdlIHN3aXRjaCB0bworICoJICBS RU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tfTUFJTlRBSU5fTUFYSEVBUCBzdGF0ZSwgd2hlcmUg d2UgYWxzbyB1cGRhdGUKKyAqCSAgdGhlIG1heC1oZWFwIHdoZW4gdXBkYXRpbmcgdGhlIG1l bW9yeSBjb3VudGVyLiBUaGUgaW50ZW50aW9uIGlzIHRvCisgKgkgIGVmZmljaWVudGx5IHJl dHJpZXZlIHRoZSBsYXJnZXN0IHRyYW5zYWN0aW9uIGluIE8oMSkgdGltZSBpbnN0ZWFkIG9m CisgKgkgIGluY3VycmluZyB0aGUgY29zdCBvZiBtZW1vcnkgY291bnRlciB1cGRhdGVzIChP KGxvZyBuKSkuIFdlIHJlbWFpbiBpbgorICoJICB0aGlzIHN0YXRlIGFzIGxvbmcgYXMgdGhl IG51bWJlciBvZiB0cmFuc2FjdGlvbnMgaXMgbGFyZ2VyIHRoYW4gdGhlCisgKgkgIHRocmVz aG9sZCwgUkVPUkRFUl9CVUZGRVJfTUVNX1RSQUNLX1RIUkVTSE9MRC4gT3RoZXJ3aXNlLCB3 ZSBzd2l0Y2ggYmFjaworICoJICB0byBSRU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tfTk9fTUFY SEVBUCBhbmQgcmVzZXQgdGhlIG1heC1oZWFwLgorICoKICAqCSAgV2Ugc3RpbGwgcmVseSBv biBtYXhfY2hhbmdlc19pbl9tZW1vcnkgd2hlbiBsb2FkaW5nIHNlcmlhbGl6ZWQgY2hhbmdl cwogICoJICBiYWNrIGludG8gbWVtb3J5LiBBdCB0aGF0IHBvaW50IHdlIGNhbid0IHVzZSB0 aGUgbWVtb3J5IGxpbWl0IGRpcmVjdGx5CiAgKgkgIGFzIHdlIGxvYWQgdGhlIHN1YnhhY3Rz IGluZGVwZW5kZW50bHkuIE9uZSBvcHRpb24gdG8gZGVhbCB3aXRoIHRoaXMKQEAgLTEwOSw2 ICsxMjksMTEgQEAKICNpbmNsdWRlICJ1dGlscy9yZWwuaCIKICNpbmNsdWRlICJ1dGlscy9y ZWxmaWxlbnVtYmVybWFwLmgiCiAKKy8qCisgKiBUaGUgdGhyZXNob2xkIG9mIHRoZSBudW1i ZXIgb2YgdHJhbnNhY3Rpb25zIGluIHRoZSBtYXgtaGVhcCAocmItPnR4bl9oZWFwKQorICog dG8gc3dpdGNoIHRoZSBzdGF0ZS4KKyAqLworI2RlZmluZSBSRU9SREVSX0JVRkZFUl9NRU1f VFJBQ0tfVEhSRVNIT0xEIDEwMjQKIAogLyogZW50cnkgZm9yIGEgaGFzaCB0YWJsZSB3ZSB1 c2UgdG8gbWFwIGZyb20geGlkIHRvIG91ciB0cmFuc2FjdGlvbiBzdGF0ZSAqLwogdHlwZWRl ZiBzdHJ1Y3QgUmVvcmRlckJ1ZmZlclRYTkJ5SWRFbnQKQEAgLTI5Niw2ICszMjEsOSBAQCBz dGF0aWMgU2l6ZSBSZW9yZGVyQnVmZmVyQ2hhbmdlU2l6ZShSZW9yZGVyQnVmZmVyQ2hhbmdl ICpjaGFuZ2UpOwogc3RhdGljIHZvaWQgUmVvcmRlckJ1ZmZlckNoYW5nZU1lbW9yeVVwZGF0 ZShSZW9yZGVyQnVmZmVyICpyYiwKIAkJCQkJCQkJCQkJUmVvcmRlckJ1ZmZlckNoYW5nZSAq Y2hhbmdlLAogCQkJCQkJCQkJCQlib29sIGFkZGl0aW9uLCBTaXplIHN6KTsKK3N0YXRpYyBp bnQgUmVvcmRlckJ1ZmZlclRYTlNpemVDb21wYXJlKERhdHVtIGEsIERhdHVtIGIsIHZvaWQg KmFyZyk7CitzdGF0aWMgdm9pZCBSZW9yZGVyQnVmZmVyVFhOTWVtb3J5VXBkYXRlKFJlb3Jk ZXJCdWZmZXIgKnJiLCBSZW9yZGVyQnVmZmVyVFhOICp0eG4sCisJCQkJCQkJCQkJIGJvb2wg YWRkaXRpb24sIFNpemUgc3opOwogCiAvKgogICogQWxsb2NhdGUgYSBuZXcgUmVvcmRlckJ1 ZmZlciBhbmQgY2xlYW4gb3V0IGFueSBvbGQgc2VyaWFsaXplZCBzdGF0ZSBmcm9tCkBAIC0z NTcsNiArMzg1LDE1IEBAIFJlb3JkZXJCdWZmZXJBbGxvY2F0ZSh2b2lkKQogCWJ1ZmZlci0+ b3V0YnVmc2l6ZSA9IDA7CiAJYnVmZmVyLT5zaXplID0gMDsKIAorCS8qCisJICogRG9uJ3Qg c3RhcnQgd2l0aCBhIGxvd2VyIG51bWJlciB0aGFuIFJFT1JERVJfQlVGRkVSX01FTV9UUkFD S19USFJFU0hPTEQsIHNpbmNlCisJICogd2UgYWRkIGF0IGxlYXN0IFJFT1JERVJfQlVGRkVS X01FTV9UUkFDS19USFJFU0hPTEQgZW50cmllcyBhdCBvbmNlLgorCSAqLworCWJ1ZmZlci0+ bWVtdHJhY2tfc3RhdGUgPSBSRU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tfTk9fTUFYSEVBUDsK KwlidWZmZXItPnR4bl9oZWFwID0gYmluYXJ5aGVhcF9hbGxvY2F0ZShSRU9SREVSX0JVRkZF Ul9NRU1fVFJBQ0tfVEhSRVNIT0xEICogMiwKKwkJCQkJCQkJCQkgICBSZW9yZGVyQnVmZmVy VFhOU2l6ZUNvbXBhcmUsCisJCQkJCQkJCQkJICAgdHJ1ZSwgTlVMTCk7CisKIAlidWZmZXIt PnNwaWxsVHhucyA9IDA7CiAJYnVmZmVyLT5zcGlsbENvdW50ID0gMDsKIAlidWZmZXItPnNw aWxsQnl0ZXMgPSAwOwpAQCAtMTUwMCw2ICsxNTM3LDcgQEAgUmVvcmRlckJ1ZmZlckNsZWFu dXBUWE4oUmVvcmRlckJ1ZmZlciAqcmIsIFJlb3JkZXJCdWZmZXJUWE4gKnR4bikKIHsKIAli b29sCQlmb3VuZDsKIAlkbGlzdF9tdXRhYmxlX2l0ZXIgaXRlcjsKKwlTaXplCQltZW1fZnJl ZWQgPSAwOwogCiAJLyogY2xlYW51cCBzdWJ0cmFuc2FjdGlvbnMgJiB0aGVpciBjaGFuZ2Vz ICovCiAJZGxpc3RfZm9yZWFjaF9tb2RpZnkoaXRlciwgJnR4bi0+c3VidHhucykKQEAgLTE1 MjksOSArMTU2NywxNSBAQCBSZW9yZGVyQnVmZmVyQ2xlYW51cFRYTihSZW9yZGVyQnVmZmVy ICpyYiwgUmVvcmRlckJ1ZmZlclRYTiAqdHhuKQogCQkvKiBDaGVjayB3ZSdyZSBub3QgbWl4 aW5nIGNoYW5nZXMgZnJvbSBkaWZmZXJlbnQgdHJhbnNhY3Rpb25zLiAqLwogCQlBc3NlcnQo Y2hhbmdlLT50eG4gPT0gdHhuKTsKIAotCQlSZW9yZGVyQnVmZmVyUmV0dXJuQ2hhbmdlKHJi LCBjaGFuZ2UsIHRydWUpOworCQltZW1fZnJlZWQgKz0gUmVvcmRlckJ1ZmZlckNoYW5nZVNp emUoY2hhbmdlKTsKKwkJUmVvcmRlckJ1ZmZlclJldHVybkNoYW5nZShyYiwgY2hhbmdlLCBm YWxzZSk7CiAJfQogCisJLyogVXBkYXRlIHRoZSBtZW1vcnkgY291bnRlciAqLworCUFzc2Vy dChtZW1fZnJlZWQgPT0gdHhuLT5zaXplKTsKKwlpZiAobWVtX2ZyZWVkID4gMCkKKwkJUmVv cmRlckJ1ZmZlclRYTk1lbW9yeVVwZGF0ZShyYiwgdHhuLCBmYWxzZSwgbWVtX2ZyZWVkKTsK KwogCS8qCiAJICogQ2xlYW51cCB0aGUgdHVwbGVjaWRzIHdlIHN0b3JlZCBmb3IgZGVjb2Rp bmcgY2F0YWxvZyBzbmFwc2hvdCBhY2Nlc3MuCiAJICogVGhleSBhcmUgYWx3YXlzIHN0b3Jl ZCBpbiB0aGUgdG9wbGV2ZWwgdHJhbnNhY3Rpb24uCkBAIC0xNTkwLDYgKzE2MzQsMjIgQEAg UmVvcmRlckJ1ZmZlckNsZWFudXBUWE4oUmVvcmRlckJ1ZmZlciAqcmIsIFJlb3JkZXJCdWZm ZXJUWE4gKnR4bikKIAogCS8qIGRlYWxsb2NhdGUgKi8KIAlSZW9yZGVyQnVmZmVyUmV0dXJu VFhOKHJiLCB0eG4pOworCisJLyoKKwkgKiBDaGVjayBpZiB0aGUgbnVtYmVyIG9mIHRyYW5z YWN0aW9ucyBnZXQgbG93ZXIgdGhhbiB0aGUgdGhyZXNob2xkLiBJZgorCSAqIHNvLCBzd2l0 Y2ggdG8gTk9fTUFYSEVBUCBzdGF0ZSBhbmQgcmVzZXQgdGhlIG1heC1oZWFwLgorCSAqCisJ ICogWFhYOiBJZiBhIG5ldyB0cmFuc2FjdGlvbiBpcyBhZGRlZCBhbmQgdGhlIG1lbW9yeSB1 c2FnZSByZWFjaGVkIHRoZQorCSAqIGxpbWl0IHNvb24sIHdlIHdpbGwgZW5kIHVwIGJ1aWxk aW5nIHRoZSBtYXgtaGVhcCBhZ2Fpbi4gSXQgbWlnaHQgYmUKKwkgKiBtb3JlIGVmZmljaWVu dCBpZiB3ZSBhY2NlcHQgYSBjZXJ0YWluIGFtb3VudCBvZiB0cmFuc2FjdGlvbnMgdG8gc3dp dGNoCisJICogYmFjayB0byB0aGUgTk9fTUFYSEVBUCBzdGF0ZSwgc2F5IDk1JSBvZiB0aGUg dGhyZXNob2xkLgorCSAqLworCWlmIChyYi0+bWVtdHJhY2tfc3RhdGUgPT0gUkVPUkRFUl9C VUZGRVJfTUVNX1RSQUNLX01BSU5UQUlOX01BWEhFQVAgJiYKKwkJKGJpbmFyeWhlYXBfc2l6 ZShyYi0+dHhuX2hlYXApIDwgUkVPUkRFUl9CVUZGRVJfTUVNX1RSQUNLX1RIUkVTSE9MRCkp CisJeworCQlyYi0+bWVtdHJhY2tfc3RhdGUgPSBSRU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tf Tk9fTUFYSEVBUDsKKwkJYmluYXJ5aGVhcF9yZXNldChyYi0+dHhuX2hlYXApOworCX0KIH0K IAogLyoKQEAgLTMxNjIsMTYgKzMyMjIsNiBAQCBSZW9yZGVyQnVmZmVyQWRkTmV3Q29tbWFu ZElkKFJlb3JkZXJCdWZmZXIgKnJiLCBUcmFuc2FjdGlvbklkIHhpZCwKIAogLyoKICAqIFVw ZGF0ZSBtZW1vcnkgY291bnRlcnMgdG8gYWNjb3VudCBmb3IgdGhlIG5ldyBvciByZW1vdmVk IGNoYW5nZS4KLSAqCi0gKiBXZSB1cGRhdGUgdHdvIGNvdW50ZXJzIC0gaW4gdGhlIHJlb3Jk ZXIgYnVmZmVyLCBhbmQgaW4gdGhlIHRyYW5zYWN0aW9uCi0gKiBjb250YWluaW5nIHRoZSBj aGFuZ2UuIFRoZSByZW9yZGVyIGJ1ZmZlciBjb3VudGVyIGFsbG93cyB1cyB0byBxdWlja2x5 Ci0gKiBkZWNpZGUgaWYgd2UgcmVhY2hlZCB0aGUgbWVtb3J5IGxpbWl0LCB0aGUgdHJhbnNh Y3Rpb24gY291bnRlciBhbGxvd3MKLSAqIHVzIHRvIHF1aWNrbHkgcGljayB0aGUgbGFyZ2Vz dCB0cmFuc2FjdGlvbiBmb3IgZXZpY3Rpb24uCi0gKgotICogV2hlbiBzdHJlYW1pbmcgaXMg ZW5hYmxlZCwgd2UgbmVlZCB0byB1cGRhdGUgdGhlIHRvcGxldmVsIHRyYW5zYWN0aW9uCi0g KiBjb3VudGVycyBpbnN0ZWFkIC0gd2UgZG9uJ3QgcmVhbGx5IGNhcmUgYWJvdXQgc3VidHJh bnNhY3Rpb25zIGFzIHdlCi0gKiBjYW4ndCBzdHJlYW0gdGhlbSBpbmRpdmlkdWFsbHkgYW55 d2F5LCBhbmQgd2Ugb25seSBwaWNrIHRvcGxldmVsCi0gKiB0cmFuc2FjdGlvbnMgZm9yIGV2 aWN0aW9uLiBTbyBvbmx5IHRvcGxldmVsIHRyYW5zYWN0aW9ucyBtYXR0ZXIuCiAgKi8KIHN0 YXRpYyB2b2lkCiBSZW9yZGVyQnVmZmVyQ2hhbmdlTWVtb3J5VXBkYXRlKFJlb3JkZXJCdWZm ZXIgKnJiLApAQCAtMzE3OSw3ICszMjI5LDYgQEAgUmVvcmRlckJ1ZmZlckNoYW5nZU1lbW9y eVVwZGF0ZShSZW9yZGVyQnVmZmVyICpyYiwKIAkJCQkJCQkJYm9vbCBhZGRpdGlvbiwgU2l6 ZSBzeikKIHsKIAlSZW9yZGVyQnVmZmVyVFhOICp0eG47Ci0JUmVvcmRlckJ1ZmZlclRYTiAq dG9wdHhuOwogCiAJQXNzZXJ0KGNoYW5nZS0+dHhuKTsKIApAQCAtMzE5Myw2ICszMjQyLDI4 IEBAIFJlb3JkZXJCdWZmZXJDaGFuZ2VNZW1vcnlVcGRhdGUoUmVvcmRlckJ1ZmZlciAqcmIs CiAKIAl0eG4gPSBjaGFuZ2UtPnR4bjsKIAorCVJlb3JkZXJCdWZmZXJUWE5NZW1vcnlVcGRh dGUocmIsIHR4biwgYWRkaXRpb24sIHN6KTsKK30KKworLyoKKyAqIFVwZGF0ZSBtZW1vcnkg Y291bnRlciBvZiB0aGUgZ2l2ZW4gdHJhbnNhY3Rpb24uCisgKgorICogV2UgdXBkYXRlIHR3 byBjb3VudGVycyAtIGluIHRoZSByZW9yZGVyIGJ1ZmZlciwgYW5kIGluIHRoZSB0cmFuc2Fj dGlvbgorICogY29udGFpbmluZyB0aGUgY2hhbmdlLiBUaGUgcmVvcmRlciBidWZmZXIgY291 bnRlciBhbGxvd3MgdXMgdG8gcXVpY2tseQorICogZGVjaWRlIGlmIHdlIHJlYWNoZWQgdGhl IG1lbW9yeSBsaW1pdCwgdGhlIHRyYW5zYWN0aW9uIGNvdW50ZXIgYWxsb3dzCisgKiB1cyB0 byBxdWlja2x5IHBpY2sgdGhlIGxhcmdlc3QgdHJhbnNhY3Rpb24gZm9yIGV2aWN0aW9uLgor ICoKKyAqIFdoZW4gc3RyZWFtaW5nIGlzIGVuYWJsZWQsIHdlIG5lZWQgdG8gdXBkYXRlIHRo ZSB0b3BsZXZlbCB0cmFuc2FjdGlvbgorICogY291bnRlcnMgaW5zdGVhZCAtIHdlIGRvbid0 IHJlYWxseSBjYXJlIGFib3V0IHN1YnRyYW5zYWN0aW9ucyBhcyB3ZQorICogY2FuJ3Qgc3Ry ZWFtIHRoZW0gaW5kaXZpZHVhbGx5IGFueXdheSwgYW5kIHdlIG9ubHkgcGljayB0b3BsZXZl bAorICogdHJhbnNhY3Rpb25zIGZvciBldmljdGlvbi4gU28gb25seSB0b3BsZXZlbCB0cmFu c2FjdGlvbnMgbWF0dGVyLgorICovCitzdGF0aWMgdm9pZAorUmVvcmRlckJ1ZmZlclRYTk1l bW9yeVVwZGF0ZShSZW9yZGVyQnVmZmVyICpyYiwgUmVvcmRlckJ1ZmZlclRYTiAqdHhuLAor CQkJCQkJCSBib29sIGFkZGl0aW9uLCBTaXplIHN6KQoreworCVJlb3JkZXJCdWZmZXJUWE4g KnRvcHR4bjsKKwogCS8qCiAJICogVXBkYXRlIHRoZSB0b3RhbCBzaXplIGluIHRvcCBsZXZl bCBhcyB3ZWxsLiBUaGlzIGlzIGxhdGVyIHVzZWQgdG8KIAkgKiBjb21wdXRlIHRoZSBkZWNv ZGluZyBzdGF0cy4KQEAgLTMyMDYsNiArMzI3NywxNSBAQCBSZW9yZGVyQnVmZmVyQ2hhbmdl TWVtb3J5VXBkYXRlKFJlb3JkZXJCdWZmZXIgKnJiLAogCiAJCS8qIFVwZGF0ZSB0aGUgdG90 YWwgc2l6ZSBpbiB0aGUgdG9wIHRyYW5zYWN0aW9uLiAqLwogCQl0b3B0eG4tPnRvdGFsX3Np emUgKz0gc3o7CisKKwkJLyogVXBkYXRlIHRoZSBtYXgtaGVhcCBhcyB3ZWxsIGlmIG5lY2Vz c2FyeSAqLworCQlpZiAocmItPm1lbXRyYWNrX3N0YXRlID09IFJFT1JERVJfQlVGRkVSX01F TV9UUkFDS19NQUlOVEFJTl9NQVhIRUFQKQorCQl7CisJCQlpZiAoKHR4bi0+c2l6ZSAtIHN6 KSA9PSAwKQorCQkJCWJpbmFyeWhlYXBfYWRkKHJiLT50eG5faGVhcCwgUG9pbnRlckdldERh dHVtKHR4bikpOworCQkJZWxzZQorCQkJCWJpbmFyeWhlYXBfdXBkYXRlX3VwKHJiLT50eG5f aGVhcCwgUG9pbnRlckdldERhdHVtKHR4bikpOworCQl9CiAJfQogCWVsc2UKIAl7CkBAIC0z MjE1LDYgKzMyOTUsMTUgQEAgUmVvcmRlckJ1ZmZlckNoYW5nZU1lbW9yeVVwZGF0ZShSZW9y ZGVyQnVmZmVyICpyYiwKIAogCQkvKiBVcGRhdGUgdGhlIHRvdGFsIHNpemUgaW4gdGhlIHRv cCB0cmFuc2FjdGlvbi4gKi8KIAkJdG9wdHhuLT50b3RhbF9zaXplIC09IHN6OworCisJCS8q IFVwZGF0ZSB0aGUgbWF4LWhlYXAgYXMgd2VsbCBpZiBuZWNlc3NhcnkgKi8KKwkJaWYgKHJi LT5tZW10cmFja19zdGF0ZSA9PSBSRU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tfTUFJTlRBSU5f TUFYSEVBUCkKKwkJeworCQkJaWYgKHR4bi0+c2l6ZSA9PSAwKQorCQkJCWJpbmFyeWhlYXBf cmVtb3ZlX25vZGVfcHRyKHJiLT50eG5faGVhcCwgUG9pbnRlckdldERhdHVtKHR4bikpOwor CQkJZWxzZQorCQkJCWJpbmFyeWhlYXBfdXBkYXRlX2Rvd24ocmItPnR4bl9oZWFwLCBQb2lu dGVyR2V0RGF0dW0odHhuKSk7CisJCX0KIAl9CiAKIAlBc3NlcnQodHhuLT5zaXplIDw9IHJi LT5zaXplKTsKQEAgLTM0NzIsMzEgKzM1NjEsNDUgQEAgUmVvcmRlckJ1ZmZlclNlcmlhbGl6 ZVJlc2VydmUoUmVvcmRlckJ1ZmZlciAqcmIsIFNpemUgc3opCiAKIC8qCiAgKiBGaW5kIHRo ZSBsYXJnZXN0IHRyYW5zYWN0aW9uICh0b3BsZXZlbCBvciBzdWJ4YWN0KSB0byBldmljdCAo c3BpbGwgdG8gZGlzaykuCi0gKgotICogWFhYIFdpdGggbWFueSBzdWJ0cmFuc2FjdGlvbnMg dGhpcyBtaWdodCBiZSBxdWl0ZSBzbG93LCBiZWNhdXNlIHdlJ2xsIGhhdmUKLSAqIHRvIHdh bGsgdGhyb3VnaCBhbGwgb2YgdGhlbS4gVGhlcmUgYXJlIHNvbWUgb3B0aW9ucyBob3cgd2Ug Y291bGQgaW1wcm92ZQotICogdGhhdDogKGEpIG1haW50YWluIHNvbWUgc2Vjb25kYXJ5IHN0 cnVjdHVyZSB3aXRoIHRyYW5zYWN0aW9ucyBzb3J0ZWQgYnkKLSAqIGFtb3VudCBvZiBjaGFu Z2VzLCAoYikgbm90IGxvb2tpbmcgZm9yIHRoZSBlbnRpcmVseSBsYXJnZXN0IHRyYW5zYWN0 aW9uLAotICogYnV0IGUuZy4gZm9yIHRyYW5zYWN0aW9uIHVzaW5nIGF0IGxlYXN0IHNvbWUg ZnJhY3Rpb24gb2YgdGhlIG1lbW9yeSBsaW1pdCwKLSAqIGFuZCAoYykgZXZpY3RpbmcgbXVs dGlwbGUgdHJhbnNhY3Rpb25zIGF0IG9uY2UsIGUuZy4gdG8gZnJlZSBhIGdpdmVuIHBvcnRp b24KLSAqIG9mIHRoZSBtZW1vcnkgbGltaXQgKGUuZy4gNTAlKS4KICAqLwogc3RhdGljIFJl b3JkZXJCdWZmZXJUWE4gKgogUmVvcmRlckJ1ZmZlckxhcmdlc3RUWE4oUmVvcmRlckJ1ZmZl ciAqcmIpCiB7Ci0JSEFTSF9TRVFfU1RBVFVTIGhhc2hfc2VxOwotCVJlb3JkZXJCdWZmZXJU WE5CeUlkRW50ICplbnQ7CiAJUmVvcmRlckJ1ZmZlclRYTiAqbGFyZ2VzdCA9IE5VTEw7CiAK LQloYXNoX3NlcV9pbml0KCZoYXNoX3NlcSwgcmItPmJ5X3R4bik7Ci0Jd2hpbGUgKChlbnQg PSBoYXNoX3NlcV9zZWFyY2goJmhhc2hfc2VxKSkgIT0gTlVMTCkKKwkvKgorCSAqIEJ1aWxk IHRoZSBtYXgtaGVhcCB0byBwaWNrIHRoZSBsYXJnZXN0IHRyYW5zYWN0aW9uIGlmIG5vdCB5 ZXQuIFdlIHdpbGwKKwkgKiBydW4gYSBoZWFwIGFzc2VtYmx5IHN0ZXAgYXQgdGhlIGVuZCwg d2hpY2ggaXMgbW9yZSBlZmZpY2llbnQuCisJICovCisJaWYgKHJiLT5tZW10cmFja19zdGF0 ZSA9PSBSRU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tfTk9fTUFYSEVBUCkKIAl7Ci0JCVJlb3Jk ZXJCdWZmZXJUWE4gKnR4biA9IGVudC0+dHhuOworCQlIQVNIX1NFUV9TVEFUVVMgaGFzaF9z ZXE7CisJCVJlb3JkZXJCdWZmZXJUWE5CeUlkRW50ICplbnQ7CiAKLQkJLyogaWYgdGhlIGN1 cnJlbnQgdHJhbnNhY3Rpb24gaXMgbGFyZ2VyLCByZW1lbWJlciBpdCAqLwotCQlpZiAoKCFs YXJnZXN0KSB8fCAodHhuLT5zaXplID4gbGFyZ2VzdC0+c2l6ZSkpCi0JCQlsYXJnZXN0ID0g dHhuOworCQloYXNoX3NlcV9pbml0KCZoYXNoX3NlcSwgcmItPmJ5X3R4bik7CisJCXdoaWxl ICgoZW50ID0gaGFzaF9zZXFfc2VhcmNoKCZoYXNoX3NlcSkpICE9IE5VTEwpCisJCXsKKwkJ CVJlb3JkZXJCdWZmZXJUWE4gKnR4biA9IGVudC0+dHhuOworCisJCQlpZiAodHhuLT5zaXpl ID09IDApCisJCQkJY29udGludWU7CisKKwkJCWJpbmFyeWhlYXBfYWRkX3Vub3JkZXJlZChy Yi0+dHhuX2hlYXAsIFBvaW50ZXJHZXREYXR1bSh0eG4pKTsKKwkJfQorCisJCWJpbmFyeWhl YXBfYnVpbGQocmItPnR4bl9oZWFwKTsKKworCQkvKgorCQkgKiBUaGUgbWF4LWhlYXAgaXMg cmVhZHkgbm93LiBXZSByZW1haW4gaW4gdGhpcyBzdGF0ZSBhdCBsZWFzdCB1bnRpbAorCQkg KiB3ZSBmcmVlIHVwIGVub3VnaCB0cmFuc2FjdGlvbnMgdG8gYnJpbmcgdGhlIHRvdGFsIG1l bW9yeSB1c2FnZQorCQkgKiBiZWxvdyB0aGUgbGltaXQuCisJCSAqLworCQlyYi0+bWVtdHJh Y2tfc3RhdGUgPSBSRU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tfTUFJTlRBSU5fTUFYSEVBUDsK IAl9CisJZWxzZQorCQlBc3NlcnQoYmluYXJ5aGVhcF9zaXplKHJiLT50eG5faGVhcCkgPiAw KTsKKworCWxhcmdlc3QgPSAoUmVvcmRlckJ1ZmZlclRYTiAqKSBEYXR1bUdldFBvaW50ZXIo YmluYXJ5aGVhcF9maXJzdChyYi0+dHhuX2hlYXApKTsKIAogCUFzc2VydChsYXJnZXN0KTsK IAlBc3NlcnQobGFyZ2VzdC0+c2l6ZSA+IDApOwpAQCAtMzYzOCw2ICszNzQxLDE4IEBAIFJl b3JkZXJCdWZmZXJDaGVja01lbW9yeUxpbWl0KFJlb3JkZXJCdWZmZXIgKnJiKQogCQlBc3Nl cnQodHhuLT5uZW50cmllc19tZW0gPT0gMCk7CiAJfQogCisJLyoKKwkgKiBDaGVjayB0aGUg bnVtYmVyIG9mIHRyYW5zYWN0aW9ucyBpbiBtYXgtaGVhcCBhZnRlciBldmljdGluZyBsYXJn ZQorCSAqIHRyYW5zYWN0aW9ucy4gSWYgdGhlIG51bWJlciBvZiB0cmFuc2FjdGlvbnMgaXMg c21hbGwsIHdlIHN3aXRjaCBiYWNrCisJICogdG8gdGhlIE5PX01BWEhFQVAgc3RhdGUsIGFu ZCByZXNldCB0aGUgY3VycmVudCB0aGUgbWF4LWhlYXAuCisJICovCisJaWYgKHJiLT5tZW10 cmFja19zdGF0ZSA9PSBSRU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tfTUFJTlRBSU5fTUFYSEVB UCAmJgorCQkoYmluYXJ5aGVhcF9zaXplKHJiLT50eG5faGVhcCkgPCBSRU9SREVSX0JVRkZF Ul9NRU1fVFJBQ0tfVEhSRVNIT0xEKSkKKwl7CisJCXJiLT5tZW10cmFja19zdGF0ZSA9IFJF T1JERVJfQlVGRkVSX01FTV9UUkFDS19OT19NQVhIRUFQOworCQliaW5hcnloZWFwX3Jlc2V0 KHJiLT50eG5faGVhcCk7CisJfQorCiAJLyogV2UgbXVzdCBiZSB1bmRlciB0aGUgbWVtb3J5 IGxpbWl0IG5vdy4gKi8KIAlBc3NlcnQocmItPnNpemUgPCBsb2dpY2FsX2RlY29kaW5nX3dv cmtfbWVtICogMTAyNEwpOwogfQpAQCAtMzY1NCw2ICszNzY5LDcgQEAgUmVvcmRlckJ1ZmZl clNlcmlhbGl6ZVRYTihSZW9yZGVyQnVmZmVyICpyYiwgUmVvcmRlckJ1ZmZlclRYTiAqdHhu KQogCVhMb2dTZWdObwljdXJPcGVuU2VnTm8gPSAwOwogCVNpemUJCXNwaWxsZWQgPSAwOwog CVNpemUJCXNpemUgPSB0eG4tPnNpemU7CisJU2l6ZQkJbWVtX2ZyZWVkID0gMDsKIAogCWVs b2coREVCVUcyLCAic3BpbGwgJXUgY2hhbmdlcyBpbiBYSUQgJXUgdG8gZGlzayIsCiAJCSAo dWludDMyKSB0eG4tPm5lbnRyaWVzX21lbSwgdHhuLT54aWQpOwpAQCAtMzcwNywxMSArMzgy MywxNyBAQCBSZW9yZGVyQnVmZmVyU2VyaWFsaXplVFhOKFJlb3JkZXJCdWZmZXIgKnJiLCBS ZW9yZGVyQnVmZmVyVFhOICp0eG4pCiAKIAkJUmVvcmRlckJ1ZmZlclNlcmlhbGl6ZUNoYW5n ZShyYiwgdHhuLCBmZCwgY2hhbmdlKTsKIAkJZGxpc3RfZGVsZXRlKCZjaGFuZ2UtPm5vZGUp OwotCQlSZW9yZGVyQnVmZmVyUmV0dXJuQ2hhbmdlKHJiLCBjaGFuZ2UsIHRydWUpOworCQlt ZW1fZnJlZWQgKz0gUmVvcmRlckJ1ZmZlckNoYW5nZVNpemUoY2hhbmdlKTsKKwkJUmVvcmRl ckJ1ZmZlclJldHVybkNoYW5nZShyYiwgY2hhbmdlLCBmYWxzZSk7CiAKIAkJc3BpbGxlZCsr OwogCX0KIAorCS8qIFVwZGF0ZSB0aGUgbWVtb3J5IGNvdW50ZXIgKi8KKwlBc3NlcnQobWVt X2ZyZWVkID09IHR4bi0+c2l6ZSk7CisJaWYgKG1lbV9mcmVlZCA+IDApCisJCVJlb3JkZXJC dWZmZXJUWE5NZW1vcnlVcGRhdGUocmIsIHR4biwgZmFsc2UsIG1lbV9mcmVlZCk7CisKIAkv KiB1cGRhdGUgdGhlIHN0YXRpc3RpY3MgaWZmIHdlIGhhdmUgc3BpbGxlZCBhbnl0aGluZyAq LwogCWlmIChzcGlsbGVkKQogCXsKQEAgLTUyNzMsMyArNTM5NSwyMCBAQCByZXN0YXJ0Ogog CQkqY21heCA9IGVudC0+Y21heDsKIAlyZXR1cm4gdHJ1ZTsKIH0KKworLyoKKyAqIENvbXBh cmUgYmV0d2VlbiBzaXplcyBvZiB0d28gdHJhbnNhY3Rpb25zLiBUaGlzIGlzIGZvciBhIGJp bmFyeSBoZWFwCisgKiBjb21wYXJpc29uIGZ1bmN0aW9uLgorICovCitzdGF0aWMgaW50CitS ZW9yZGVyQnVmZmVyVFhOU2l6ZUNvbXBhcmUoRGF0dW0gYSwgRGF0dW0gYiwgdm9pZCAqYXJn KQoreworCVJlb3JkZXJCdWZmZXJUWE4JKnRhID0gKFJlb3JkZXJCdWZmZXJUWE4gKikgRGF0 dW1HZXRQb2ludGVyKGEpOworCVJlb3JkZXJCdWZmZXJUWE4JKnRiID0gKFJlb3JkZXJCdWZm ZXJUWE4gKikgRGF0dW1HZXRQb2ludGVyKGIpOworCisJaWYgKHRhLT5zaXplIDwgdGItPnNp emUpCisJCXJldHVybiAtMTsKKwlpZiAodGEtPnNpemUgPiB0Yi0+c2l6ZSkKKwkJcmV0dXJu IDE7CisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9yZXBsaWNhdGlv bi9yZW9yZGVyYnVmZmVyLmggYi9zcmMvaW5jbHVkZS9yZXBsaWNhdGlvbi9yZW9yZGVyYnVm ZmVyLmgKaW5kZXggMGIyYzk1ZjdhYTAuLmYwZDM1MmNmY2M2IDEwMDY0NAotLS0gYS9zcmMv aW5jbHVkZS9yZXBsaWNhdGlvbi9yZW9yZGVyYnVmZmVyLmgKKysrIGIvc3JjL2luY2x1ZGUv cmVwbGljYXRpb24vcmVvcmRlcmJ1ZmZlci5oCkBAIC0xMCw2ICsxMCw3IEBACiAjZGVmaW5l IFJFT1JERVJCVUZGRVJfSAogCiAjaW5jbHVkZSAiYWNjZXNzL2h0dXBfZGV0YWlscy5oIgor I2luY2x1ZGUgImxpYi9iaW5hcnloZWFwLmgiCiAjaW5jbHVkZSAibGliL2lsaXN0LmgiCiAj aW5jbHVkZSAic3RvcmFnZS9zaW52YWwuaCIKICNpbmNsdWRlICJ1dGlscy9oc2VhcmNoLmgi CkBAIC01MzEsNiArNTMyLDIyIEBAIHR5cGVkZWYgdm9pZCAoKlJlb3JkZXJCdWZmZXJVcGRh dGVQcm9ncmVzc1R4bkNCKSAoCiAJCQkJCQkJCQkJCQkgIFJlb3JkZXJCdWZmZXJUWE4gKnR4 biwKIAkJCQkJCQkJCQkJCSAgWExvZ1JlY1B0ciBsc24pOwogCisvKiBTdGF0ZSBvZiBob3cg dG8gdHJhY2sgdGhlIG1lbW9yeSB1c2FnZSBvZiBlYWNoIHRyYW5zYWN0aW9uIGJlaW5nIGRl Y29kZWQgKi8KK3R5cGVkZWYgZW51bSBSZW9yZGVyQnVmZmVyTWVtVHJhY2tTdGF0ZQorewor CS8qCisJICogV2UgZG9uJ3QgdXBkYXRlIG1heC1oZWFwIHdoaWxlIHVwZGF0aW5nIHRoZSBt ZW1vcnkgY291bnRlci4gVGhlCisJICogbWF4LWhlYXAgaXMgYnVpbHQgYmVmb3JlIHVzZS4K KwkgKi8KKwlSRU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tfTk9fTUFYSEVBUCwKKworCS8qCisJ ICogV2UgYWxzbyB1cGRhdGUgdGhlIG1heC1oZWFwIHdoZW4gdXBkYXRpbmcgdGhlIG1lbW9y eSBjb3VudGVyIHNvCisJICogdGhlIGhlYXAgcHJvcGVydHkgaXMgYWx3YXlzIHByZXNlcnZl ZC4KKwkgKi8KKwlSRU9SREVSX0JVRkZFUl9NRU1fVFJBQ0tfTUFJTlRBSU5fTUFYSEVBUCwK K30gUmVvcmRlckJ1ZmZlck1lbVRyYWNrU3RhdGU7CisKIHN0cnVjdCBSZW9yZGVyQnVmZmVy CiB7CiAJLyoKQEAgLTYzMSw2ICs2NDgsMTAgQEAgc3RydWN0IFJlb3JkZXJCdWZmZXIKIAkv KiBtZW1vcnkgYWNjb3VudGluZyAqLwogCVNpemUJCXNpemU7CiAKKwkvKiBNYXgtaGVhcCBm b3Igc2l6ZXMgb2YgYWxsIHRvcC1sZXZlbCBhbmQgc3ViIHRyYW5zYWN0aW9ucyAqLworCVJl b3JkZXJCdWZmZXJNZW1UcmFja1N0YXRlIG1lbXRyYWNrX3N0YXRlOworCWJpbmFyeWhlYXAJ KnR4bl9oZWFwOworCiAJLyoKIAkgKiBTdGF0aXN0aWNzIGFib3V0IHRyYW5zYWN0aW9ucyBz cGlsbGVkIHRvIGRpc2suCiAJICoKLS0gCjIuNDMuMAoK --------------9aa4PS6RDhvp5jfrDfxgDS8r Content-Type: text/x-patch; charset=UTF-8; name="v5-0003-review.patch" Content-Disposition: attachment; filename="v5-0003-review.patch" Content-Transfer-Encoding: base64 RnJvbSBmMmI1NGZiYjJiYzBiNmE3NGQxMGY0NmIwODZlMjM4ZDc2ZmU4MjJmIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb21hcyBWb25kcmEgPHRvbWFzQDJuZHF1YWRyYW50 LmNvbT4KRGF0ZTogRnJpLCAyMyBGZWIgMjAyNCAxMzozMjowNCArMDEwMApTdWJqZWN0OiBb UEFUQ0ggdjUgMy81XSByZXZpZXcKCi0tLQogc3JjL2NvbW1vbi9iaW5hcnloZWFwLmMgfCAy MSArKysrKysrKysrKysrKysrLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAxNiBpbnNlcnRpb25z KCspLCA1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9jb21tb24vYmluYXJ5aGVh cC5jIGIvc3JjL2NvbW1vbi9iaW5hcnloZWFwLmMKaW5kZXggZmYwM2M0NzdkYzkuLmY2NTZj NDc1MjRlIDEwMDY0NAotLS0gYS9zcmMvY29tbW9uL2JpbmFyeWhlYXAuYworKysgYi9zcmMv Y29tbW9uL2JpbmFyeWhlYXAuYwpAQCAtNTQsNiArNTQsOCBAQCBzdGF0aWMgdm9pZCBzaWZ0 X3VwKGJpbmFyeWhlYXAgKmhlYXAsIGludCBub2RlX29mZik7CiAgKiBzdG9yZSB0aGUgZ2l2 ZW4gbnVtYmVyIG9mIG5vZGVzLCB3aXRoIHRoZSBoZWFwIHByb3BlcnR5IGRlZmluZWQgYnkK ICAqIHRoZSBnaXZlbiBjb21wYXJhdG9yIGZ1bmN0aW9uLCB3aGljaCB3aWxsIGJlIGludm9r ZWQgd2l0aCB0aGUgYWRkaXRpb25hbAogICogYXJndW1lbnQgc3BlY2lmaWVkIGJ5ICdhcmcn LgorICoKKyAqIFhYWCBTaG91bGQgZG9jdW1lbnQgdGhlIG5ldyAiaW5kZXhlZCIgYXJndW1l bnQuCiAgKi8KIGJpbmFyeWhlYXAgKgogYmluYXJ5aGVhcF9hbGxvY2F0ZShpbnQgY2FwYWNp dHksIGJpbmFyeWhlYXBfY29tcGFyYXRvciBjb21wYXJlLApAQCAtMTEwLDYgKzExMiw3IEBA IGJpbmFyeWhlYXBfZnJlZShiaW5hcnloZWFwICpoZWFwKQogewogCWlmIChoZWFwLT5iaF9p bmRleGVkKQogCQliaF9ub2RlaWR4X2Rlc3Ryb3koaGVhcC0+Ymhfbm9kZWlkeCk7CisKIAlw ZnJlZShoZWFwKTsKIH0KIApAQCAtMTUyLDI4ICsxNTUsMzQgQEAgYmhfZW5sYXJnZV9ub2Rl X2FycmF5KGJpbmFyeWhlYXAgKmhlYXApCiB9CiAKIC8qCi0gKiBTZXQgdGhlIGdpdmVuIG5v ZGUgYXQgdGhlICdpZHgnIGFuZCB1cGRhdGVzIGl0cyBwb3NpdGlvbiBhY2NvcmRpbmdseS4K KyAqIFNldCB0aGUgZ2l2ZW4gbm9kZSBhdCB0aGUgJ2luZGV4JyBhbmQgdXBkYXRlcyBpdHMg cG9zaXRpb24gYWNjb3JkaW5nbHkuCisgKgorICogWFhYIE5vIG5lZWQgdG8gc2hvcnRlbiB0 aGUgYXJndW1lbnQgbmFtZXMsIEkgdGhpbmsuCisgKgorICogWFhYIFNob3VsZCB0aGlzIHJl dHVybiAiZm91bmQiIG1heWJlPwogICovCiBzdGF0aWMgdm9pZAotYmhfc2V0X25vZGUoYmlu YXJ5aGVhcCAqaGVhcCwgYmhfbm9kZV90eXBlIGQsIGludCBpZHgpCitiaF9zZXRfbm9kZShi aW5hcnloZWFwICpoZWFwLCBiaF9ub2RlX3R5cGUgbm9kZSwgaW50IGluZGV4KQogewogCWJo X25vZGVpZHhfZW50cnkgKmVudDsKIAlib29sCWZvdW5kOwogCiAJLyogU2V0IHRoZSBub2Rl IHRvIHRoZSBub2RlcyBhcnJheSAqLwotCWhlYXAtPmJoX25vZGVzW2lkeF0gPSBkOworCWhl YXAtPmJoX25vZGVzW2luZGV4XSA9IG5vZGU7CiAKIAlpZiAoaGVhcC0+YmhfaW5kZXhlZCkK IAl7CiAJCS8qIFJlbWVtYmVyIGl0cyBpbmRleCBpbiB0aGUgbm9kZXMgYXJyYXkgKi8KLQkJ ZW50ID0gYmhfbm9kZWlkeF9pbnNlcnQoaGVhcC0+Ymhfbm9kZWlkeCwgZCwgJmZvdW5kKTsK LQkJZW50LT5pZHggPSBpZHg7CisJCWVudCA9IGJoX25vZGVpZHhfaW5zZXJ0KGhlYXAtPmJo X25vZGVpZHgsIG5vZGUsICZmb3VuZCk7CisJCWVudC0+aWR4ID0gaW5kZXg7CiAJfQogfQog CiAvKgogICogUmVwbGFjZSB0aGUgbm9kZSBhdCAnaWR4JyB3aXRoIHRoZSBnaXZlbiBub2Rl ICdyZXBsYWNlZF9ieScuIEFsc28KICAqIHVwZGF0ZSB0aGVpciBwb3NpdGlvbnMgYWNjb3Jk aW5nbHkuCisgKgorICogWFhYIGNhbiB3ZSBkbyBBc3NlcnQoZm91bmQpIGhlcmU/IGlmIGJo X3NldF9ub2RlIHJldHVybnMgaXQsIG9mYwogICovCiBzdGF0aWMgdm9pZAogYmhfcmVwbGFj ZV9ub2RlKGJpbmFyeWhlYXAgKmhlYXAsIGludCBpZHgsIGJoX25vZGVfdHlwZSByZXBsYWNl ZF9ieSkKQEAgLTI4MCw2ICsyODksOCBAQCBiaW5hcnloZWFwX3JlbW92ZV9maXJzdChiaW5h cnloZWFwICpoZWFwKQogCXsKIAkJaGVhcC0+Ymhfc2l6ZS0tOwogCisJCS8qIFhYWCBtYXli ZSBpdCdkIGJlIGdvb2QgdG8gbWFrZSB0aGUgY2hlY2sgaW4gYmhfbm9kZWlkeF9kZWxldGUs IHNvIHRoYXQKKwkJICogd2UgZG9uJ3QgbmVlZCB0byBkbyBpdCBldmVyeXdoZXJlLiAqLwog CQlpZiAoaGVhcC0+YmhfaW5kZXhlZCkKIAkJCWJoX25vZGVpZHhfZGVsZXRlKGhlYXAtPmJo X25vZGVpZHgsIHJlc3VsdCk7CiAKLS0gCjIuNDMuMAoK --------------9aa4PS6RDhvp5jfrDfxgDS8r Content-Type: text/x-patch; charset=UTF-8; name="v5-0002-Add-functions-to-binaryheap-to-efficiently-remove.patch" Content-Disposition: attachment; filename*0="v5-0002-Add-functions-to-binaryheap-to-efficiently-remove.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSBhMmE3ZGI2ZTAyMzQ0OTgyNzY0YjA3ZWM0YmY0ZDUwOWQxZGQ3YWU0IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYXNhaGlrbyBTYXdhZGEgPHNhd2FkYS5tc2hrQGdt YWlsLmNvbT4KRGF0ZTogRnJpLCAyNiBKYW4gMjAyNCAxMToyMDoyMyArMDkwMApTdWJqZWN0 OiBbUEFUQ0ggdjUgMi81XSBBZGQgZnVuY3Rpb25zIHRvIGJpbmFyeWhlYXAgdG8gZWZmaWNp ZW50bHkKIHJlbW92ZS91cGRhdGUga2V5cy4KClByZXZpb3VzbHksIGJpbmFyeWhlYXAgZGlk bid0IHN1cHBvcnQga2V5IHVwZGF0ZXMgYW5kIHJlbW92aW5nIG5vZGVzCmluIGFuIGVmZmlj aWVudCB3YXkuIEZvciBleGFtcGxlLCBpbiBvcmRlciB0byByZW1vdmUgYSBub2RlIGZyb20g dGhlCmJpbmFyeWhlYXAsIHRoZSBjYWxsZXIgaGFzIHRvIHBhc3MgdGhlIG5vZGUncyBwb3Np dGlvbiB3aXRoaW4gdGhlCmFycmF5IHRoYXQgdGhlIGJpbmFyeWhlYXAgaW50ZXJuYWxseSBo YXMuIFJlbW92aW5nIGEgbm9kZSBmcm9tIHRoZQpiaW5hcnloZWFwIGlzIGRvbmUgaW4gTyhs b2cgbikgYnV0IHNlYXJjaGluZyBmb3IgdGhlIGtleSdzIHBvc2l0aW9uIGlzCmRvbmUgaW4g TyhuKS4KClRoaXMgY29tbWl0IGFkZHMgYSBoYXNoIHRhYmxlIHRvIGJpbmFyeWhlYXAgdG8g dHJhY2sgb2YgcG9zaXRpb25zIG9mCmVhY2ggbm9kZXMgaW4gdGhlIGJpbmFyeWhlYXAuIFRo YXQgd2F5LCBieSB1c2luZyBuZXdseSBhZGRlZApmdW5jdGlvbnMgc3VjaCBhcyBiaW5hcnlo ZWFwX3VwZGF0ZV91cCgpIGV0Yy4sIGJvdGggdXBkYXRpbmcgYSBrZXkgYW5kCnJlbW92aW5n IGEgbm9kZSBjYW4gbm9kZSBjYW4gYmUgZG9uZSBpbiBPKDEpIGluIGFuIGF2ZXJhZ2UgYW5k Ck8obG9nIG4pIGluIHdvcnN0IGNhc2UuIFRoaXMgaXMga25vd24gYXMgdGhlIGluZGV4ZWQg cHJpb3JpdHkKcXVldWUuIFRoZSBjYWxsZXIgY2FuIHNwZWNpZnkgdG8gdXNlIHRoZSBpbmRl eGVkIGJpbmFyeWhlYXAgYnkgcGFzc2luZwppbmRleGVkID0gdHJ1ZS4gVGhlcmUgaXMgbm8g dXNlciBvZiBpdCBidXQgaXQgd2lsbCBiZSB1c2VkIGJ5IGEKdXBjb21pbmcgcGF0Y2guCgpY WFg6IHVwZGF0ZSB0eXBlZGVmLmxpc3QKCkF1dGhvcjoKUmV2aWV3ZWQtYnk6CkRpc2N1c3Np b246IGh0dHBzOi8vcG9zdGdyLmVzL20vCkJhY2twYXRjaC10aHJvdWdoOgotLS0KIHNyYy9i YWNrZW5kL2V4ZWN1dG9yL25vZGVHYXRoZXJNZXJnZS5jICAgICAgICB8ICAgMSArCiBzcmMv YmFja2VuZC9leGVjdXRvci9ub2RlTWVyZ2VBcHBlbmQuYyAgICAgICAgfCAgIDIgKy0KIHNy Yy9iYWNrZW5kL3Bvc3RtYXN0ZXIvcGdhcmNoLmMgICAgICAgICAgICAgICB8ICAgMyArLQog Li4uL3JlcGxpY2F0aW9uL2xvZ2ljYWwvcmVvcmRlcmJ1ZmZlci5jICAgICAgIHwgICAxICsK IHNyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jICAgICAgICAgICB8ICAgMSAr CiBzcmMvYmluL3BnX2R1bXAvcGdfYmFja3VwX2FyY2hpdmVyLmMgICAgICAgICAgfCAgIDEg Kwogc3JjL2Jpbi9wZ19kdW1wL3BnX2R1bXBfc29ydC5jICAgICAgICAgICAgICAgIHwgICAy ICstCiBzcmMvY29tbW9uL2JpbmFyeWhlYXAuYyAgICAgICAgICAgICAgICAgICAgICAgfCAx NjcgKysrKysrKysrKysrKysrKy0tCiBzcmMvaW5jbHVkZS9saWIvYmluYXJ5aGVhcC5oICAg ICAgICAgICAgICAgICAgfCAgMzUgKysrLQogOSBmaWxlcyBjaGFuZ2VkLCAxOTkgaW5zZXJ0 aW9ucygrKSwgMTQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhl Y3V0b3Ivbm9kZUdhdGhlck1lcmdlLmMgYi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlR2F0 aGVyTWVyZ2UuYwppbmRleCAyZDU1MmY0MjI0MC4uMjUwZjIyNmQ1ZjggMTAwNjQ0Ci0tLSBh L3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVHYXRoZXJNZXJnZS5jCisrKyBiL3NyYy9iYWNr ZW5kL2V4ZWN1dG9yL25vZGVHYXRoZXJNZXJnZS5jCkBAIC00MjcsNiArNDI3LDcgQEAgZ2F0 aGVyX21lcmdlX3NldHVwKEdhdGhlck1lcmdlU3RhdGUgKmdtX3N0YXRlKQogCS8qIEFsbG9j YXRlIHRoZSByZXNvdXJjZXMgZm9yIHRoZSBtZXJnZSAqLwogCWdtX3N0YXRlLT5nbV9oZWFw ID0gYmluYXJ5aGVhcF9hbGxvY2F0ZShucmVhZGVycyArIDEsCiAJCQkJCQkJCQkJCWhlYXBf Y29tcGFyZV9zbG90cywKKwkJCQkJCQkJCQkJZmFsc2UsCiAJCQkJCQkJCQkJCWdtX3N0YXRl KTsKIH0KIApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZU1lcmdlQXBw ZW5kLmMgYi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlTWVyZ2VBcHBlbmQuYwppbmRleCAw ODE3ODY4NDUyOC4uMTk4MDc5NGNiN2EgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1 dG9yL25vZGVNZXJnZUFwcGVuZC5jCisrKyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVN ZXJnZUFwcGVuZC5jCkBAIC0xMjUsNyArMTI1LDcgQEAgRXhlY0luaXRNZXJnZUFwcGVuZChN ZXJnZUFwcGVuZCAqbm9kZSwgRVN0YXRlICplc3RhdGUsIGludCBlZmxhZ3MpCiAJbWVyZ2Vz dGF0ZS0+bXNfbnBsYW5zID0gbnBsYW5zOwogCiAJbWVyZ2VzdGF0ZS0+bXNfc2xvdHMgPSAo VHVwbGVUYWJsZVNsb3QgKiopIHBhbGxvYzAoc2l6ZW9mKFR1cGxlVGFibGVTbG90ICopICog bnBsYW5zKTsKLQltZXJnZXN0YXRlLT5tc19oZWFwID0gYmluYXJ5aGVhcF9hbGxvY2F0ZShu cGxhbnMsIGhlYXBfY29tcGFyZV9zbG90cywKKwltZXJnZXN0YXRlLT5tc19oZWFwID0gYmlu YXJ5aGVhcF9hbGxvY2F0ZShucGxhbnMsIGhlYXBfY29tcGFyZV9zbG90cywgZmFsc2UsCiAJ CQkJCQkJCQkJCSAgbWVyZ2VzdGF0ZSk7CiAKIAkvKgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvcG9zdG1hc3Rlci9wZ2FyY2guYyBiL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvcGdhcmNo LmMKaW5kZXggOWMxOGU0YjNlZmIuLjM2NTIyOTQwZGQ0IDEwMDY0NAotLS0gYS9zcmMvYmFj a2VuZC9wb3N0bWFzdGVyL3BnYXJjaC5jCisrKyBiL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIv cGdhcmNoLmMKQEAgLTI1MCw3ICsyNTAsOCBAQCBQZ0FyY2hpdmVyTWFpbih2b2lkKQogCiAJ LyogSW5pdGlhbGl6ZSBvdXIgbWF4LWhlYXAgZm9yIHByaW9yaXRpemluZyBmaWxlcyB0byBh cmNoaXZlLiAqLwogCWFyY2hfZmlsZXMtPmFyY2hfaGVhcCA9IGJpbmFyeWhlYXBfYWxsb2Nh dGUoTlVNX0ZJTEVTX1BFUl9ESVJFQ1RPUllfU0NBTiwKLQkJCQkJCQkJCQkJCXJlYWR5X2Zp bGVfY29tcGFyYXRvciwgTlVMTCk7CisJCQkJCQkJCQkJCQlyZWFkeV9maWxlX2NvbXBhcmF0 b3IsIGZhbHNlLAorCQkJCQkJCQkJCQkJTlVMTCk7CiAKIAkvKiBMb2FkIHRoZSBhcmNoaXZl X2xpYnJhcnkuICovCiAJTG9hZEFyY2hpdmVMaWJyYXJ5KCk7CmRpZmYgLS1naXQgYS9zcmMv YmFja2VuZC9yZXBsaWNhdGlvbi9sb2dpY2FsL3Jlb3JkZXJidWZmZXIuYyBiL3NyYy9iYWNr ZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvcmVvcmRlcmJ1ZmZlci5jCmluZGV4IDU0NDZkZjNj NjQ3Li45MWI5NjE4ZDdlYyAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24v bG9naWNhbC9yZW9yZGVyYnVmZmVyLmMKKysrIGIvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24v bG9naWNhbC9yZW9yZGVyYnVmZmVyLmMKQEAgLTEyOTYsNiArMTI5Niw3IEBAIFJlb3JkZXJC dWZmZXJJdGVyVFhOSW5pdChSZW9yZGVyQnVmZmVyICpyYiwgUmVvcmRlckJ1ZmZlclRYTiAq dHhuLAogCS8qIGFsbG9jYXRlIGhlYXAgKi8KIAlzdGF0ZS0+aGVhcCA9IGJpbmFyeWhlYXBf YWxsb2NhdGUoc3RhdGUtPm5yX3R4bnMsCiAJCQkJCQkJCQkgIFJlb3JkZXJCdWZmZXJJdGVy Q29tcGFyZSwKKwkJCQkJCQkJCSAgZmFsc2UsCiAJCQkJCQkJCQkgIHN0YXRlKTsKIAogCS8q IE5vdyB0aGF0IHRoZSBzdGF0ZSBmaWVsZHMgYXJlIGluaXRpYWxpemVkLCBpdCBpcyBzYWZl IHRvIHJldHVybiBpdC4gKi8KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVm ZmVyL2J1Zm1nci5jIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMKaW5k ZXggYmRmODliYmM0ZGMuLjY5ZjA3MTMyMWRkIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9z dG9yYWdlL2J1ZmZlci9idWZtZ3IuYworKysgYi9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZl ci9idWZtZ3IuYwpAQCAtMjcyNSw2ICsyNzI1LDcgQEAgQnVmZmVyU3luYyhpbnQgZmxhZ3Mp CiAJICovCiAJdHNfaGVhcCA9IGJpbmFyeWhlYXBfYWxsb2NhdGUobnVtX3NwYWNlcywKIAkJ CQkJCQkJICB0c19ja3B0X3Byb2dyZXNzX2NvbXBhcmF0b3IsCisJCQkJCQkJCSAgZmFsc2Us CiAJCQkJCQkJCSAgTlVMTCk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgbnVtX3NwYWNlczsgaSsr KQpkaWZmIC0tZ2l0IGEvc3JjL2Jpbi9wZ19kdW1wL3BnX2JhY2t1cF9hcmNoaXZlci5jIGIv c3JjL2Jpbi9wZ19kdW1wL3BnX2JhY2t1cF9hcmNoaXZlci5jCmluZGV4IGQ5N2ViYWZmNWI4 Li42NTg3YTdiMDgxNCAxMDA2NDQKLS0tIGEvc3JjL2Jpbi9wZ19kdW1wL3BnX2JhY2t1cF9h cmNoaXZlci5jCisrKyBiL3NyYy9iaW4vcGdfZHVtcC9wZ19iYWNrdXBfYXJjaGl2ZXIuYwpA QCAtNDAzMyw2ICs0MDMzLDcgQEAgcmVzdG9yZV90b2NfZW50cmllc19wYXJhbGxlbChBcmNo aXZlSGFuZGxlICpBSCwgUGFyYWxsZWxTdGF0ZSAqcHN0YXRlLAogCS8qIFNldCB1cCByZWFk eV9oZWFwIHdpdGggZW5vdWdoIHJvb20gZm9yIGFsbCBrbm93biBUb2NFbnRyeXMgKi8KIAly ZWFkeV9oZWFwID0gYmluYXJ5aGVhcF9hbGxvY2F0ZShBSC0+dG9jQ291bnQsCiAJCQkJCQkJ CQkgVG9jRW50cnlTaXplQ29tcGFyZUJpbmFyeWhlYXAsCisJCQkJCQkJCQkgZmFsc2UsCiAJ CQkJCQkJCQkgTlVMTCk7CiAKIAkvKgpkaWZmIC0tZ2l0IGEvc3JjL2Jpbi9wZ19kdW1wL3Bn X2R1bXBfc29ydC5jIGIvc3JjL2Jpbi9wZ19kdW1wL3BnX2R1bXBfc29ydC5jCmluZGV4IDhl ZThhNDI3ODFhLi40ZDEwYWYzYTM0NCAxMDA2NDQKLS0tIGEvc3JjL2Jpbi9wZ19kdW1wL3Bn X2R1bXBfc29ydC5jCisrKyBiL3NyYy9iaW4vcGdfZHVtcC9wZ19kdW1wX3NvcnQuYwpAQCAt NDA1LDcgKzQwNSw3IEBAIFRvcG9Tb3J0KER1bXBhYmxlT2JqZWN0ICoqb2JqcywKIAkJcmV0 dXJuIHRydWU7CiAKIAkvKiBDcmVhdGUgd29ya3NwYWNlIGZvciB0aGUgYWJvdmUtZGVzY3Jp YmVkIGhlYXAgKi8KLQlwZW5kaW5nSGVhcCA9IGJpbmFyeWhlYXBfYWxsb2NhdGUobnVtT2Jq cywgaW50X2NtcCwgTlVMTCk7CisJcGVuZGluZ0hlYXAgPSBiaW5hcnloZWFwX2FsbG9jYXRl KG51bU9ianMsIGludF9jbXAsIGZhbHNlLCBOVUxMKTsKIAogCS8qCiAJICogU2NhbiB0aGUg Y29uc3RyYWludHMsIGFuZCBmb3IgZWFjaCBpdGVtIGluIHRoZSBpbnB1dCwgZ2VuZXJhdGUg YSBjb3VudApkaWZmIC0tZ2l0IGEvc3JjL2NvbW1vbi9iaW5hcnloZWFwLmMgYi9zcmMvY29t bW9uL2JpbmFyeWhlYXAuYwppbmRleCA2ZjE2YzgzMjk1ZC4uZmYwM2M0NzdkYzkgMTAwNjQ0 Ci0tLSBhL3NyYy9jb21tb24vYmluYXJ5aGVhcC5jCisrKyBiL3NyYy9jb21tb24vYmluYXJ5 aGVhcC5jCkBAIC0yMiw4ICsyMiwyOCBAQAogI2lmZGVmIEZST05URU5ECiAjaW5jbHVkZSAi Y29tbW9uL2xvZ2dpbmcuaCIKICNlbmRpZgorI2luY2x1ZGUgImNvbW1vbi9oYXNoZm4uaCIK ICNpbmNsdWRlICJsaWIvYmluYXJ5aGVhcC5oIgogCisvKgorICogRGVmaW5lIHBhcmFtZXRl cnMgZm9yIGhhc2ggdGFibGUgY29kZSBnZW5lcmF0aW9uLiBUaGUgaW50ZXJmYWNlIGlzICph bHNvKiIKKyAqIGRlY2xhcmVkIGluIGJpbmFyeWhlYXBoLmggKHRvIGdlbmVyYXRlIHRoZSB0 eXBlcywgd2hpY2ggYXJlIGV4dGVybmFsbHkKKyAqIHZpc2libGUpLgorICovCisjZGVmaW5l IFNIX1BSRUZJWCBiaF9ub2RlaWR4CisjZGVmaW5lIFNIX0VMRU1FTlRfVFlQRSBiaF9ub2Rl aWR4X2VudHJ5CisjZGVmaW5lIFNIX0tFWV9UWVBFIGJoX25vZGVfdHlwZQorI2RlZmluZSBT SF9LRVkga2V5CisjZGVmaW5lIFNIX0hBU0hfS0VZKHRiLCBrZXkpIFwKKwloYXNoX2J5dGVz KChjb25zdCB1bnNpZ25lZCBjaGFyICopICZrZXksIHNpemVvZihiaF9ub2RlX3R5cGUpKQor I2RlZmluZSBTSF9FUVVBTCh0YiwgYSwgYikgKG1lbWNtcCgmYSwgJmIsIHNpemVvZihiaF9u b2RlX3R5cGUpKSA9PSAwKQorI2RlZmluZSBTSF9TQ09QRSBleHRlcm4KKyNpZmRlZiBGUk9O VEVORAorI2RlZmluZSBTSF9SQVdfQUxMT0NBVE9SIHBnX21hbGxvYzAKKyNlbmRpZgorI2Rl ZmluZSBTSF9ERUZJTkUKKyNpbmNsdWRlICJsaWIvc2ltcGxlaGFzaC5oIgorCiBzdGF0aWMg dm9pZCBzaWZ0X2Rvd24oYmluYXJ5aGVhcCAqaGVhcCwgaW50IG5vZGVfb2ZmKTsKIHN0YXRp YyB2b2lkIHNpZnRfdXAoYmluYXJ5aGVhcCAqaGVhcCwgaW50IG5vZGVfb2ZmKTsKIApAQCAt MzYsNyArNTYsOCBAQCBzdGF0aWMgdm9pZCBzaWZ0X3VwKGJpbmFyeWhlYXAgKmhlYXAsIGlu dCBub2RlX29mZik7CiAgKiBhcmd1bWVudCBzcGVjaWZpZWQgYnkgJ2FyZycuCiAgKi8KIGJp bmFyeWhlYXAgKgotYmluYXJ5aGVhcF9hbGxvY2F0ZShpbnQgY2FwYWNpdHksIGJpbmFyeWhl YXBfY29tcGFyYXRvciBjb21wYXJlLCB2b2lkICphcmcpCitiaW5hcnloZWFwX2FsbG9jYXRl KGludCBjYXBhY2l0eSwgYmluYXJ5aGVhcF9jb21wYXJhdG9yIGNvbXBhcmUsCisJCQkJCWJv b2wgaW5kZXhlZCwgdm9pZCAqYXJnKQogewogCWJpbmFyeWhlYXAgKmhlYXA7CiAKQEAgLTQ5 LDYgKzcwLDE3IEBAIGJpbmFyeWhlYXBfYWxsb2NhdGUoaW50IGNhcGFjaXR5LCBiaW5hcnlo ZWFwX2NvbXBhcmF0b3IgY29tcGFyZSwgdm9pZCAqYXJnKQogCWhlYXAtPmJoX2hhc19oZWFw X3Byb3BlcnR5ID0gdHJ1ZTsKIAloZWFwLT5iaF9ub2RlcyA9IChiaF9ub2RlX3R5cGUgKikg cGFsbG9jKHNpemVvZihiaF9ub2RlX3R5cGUpICogY2FwYWNpdHkpOwogCisJaGVhcC0+Ymhf aW5kZXhlZCA9IGluZGV4ZWQ7CisJaWYgKGhlYXAtPmJoX2luZGV4ZWQpCisJeworI2lmZGVm IEZST05URU5ECisJCWhlYXAtPmJoX25vZGVpZHggPSBiaF9ub2RlaWR4X2NyZWF0ZShjYXBh Y2l0eSwgTlVMTCk7CisjZWxzZQorCQloZWFwLT5iaF9ub2RlaWR4ID0gYmhfbm9kZWlkeF9j cmVhdGUoQ3VycmVudE1lbW9yeUNvbnRleHQsIGNhcGFjaXR5LAorCQkJCQkJCQkJCQkgTlVM TCk7CisjZW5kaWYKKwl9CisKIAlyZXR1cm4gaGVhcDsKIH0KIApAQCAtNjMsNiArOTUsOSBA QCBiaW5hcnloZWFwX3Jlc2V0KGJpbmFyeWhlYXAgKmhlYXApCiB7CiAJaGVhcC0+Ymhfc2l6 ZSA9IDA7CiAJaGVhcC0+YmhfaGFzX2hlYXBfcHJvcGVydHkgPSB0cnVlOworCisJaWYgKGhl YXAtPmJoX2luZGV4ZWQpCisJCWJoX25vZGVpZHhfcmVzZXQoaGVhcC0+Ymhfbm9kZWlkeCk7 CiB9CiAKIC8qCkBAIC03Myw2ICsxMDgsOCBAQCBiaW5hcnloZWFwX3Jlc2V0KGJpbmFyeWhl YXAgKmhlYXApCiB2b2lkCiBiaW5hcnloZWFwX2ZyZWUoYmluYXJ5aGVhcCAqaGVhcCkKIHsK KwlpZiAoaGVhcC0+YmhfaW5kZXhlZCkKKwkJYmhfbm9kZWlkeF9kZXN0cm95KGhlYXAtPmJo X25vZGVpZHgpOwogCXBmcmVlKGhlYXApOwogfQogCkBAIC0xMTQsNiArMTUxLDQ0IEBAIGJo X2VubGFyZ2Vfbm9kZV9hcnJheShiaW5hcnloZWFwICpoZWFwKQogCQkJCQkJCSAgc2l6ZW9m KGJoX25vZGVfdHlwZSkgKiBoZWFwLT5iaF9zcGFjZSk7CiB9CiAKKy8qCisgKiBTZXQgdGhl IGdpdmVuIG5vZGUgYXQgdGhlICdpZHgnIGFuZCB1cGRhdGVzIGl0cyBwb3NpdGlvbiBhY2Nv cmRpbmdseS4KKyAqLworc3RhdGljIHZvaWQKK2JoX3NldF9ub2RlKGJpbmFyeWhlYXAgKmhl YXAsIGJoX25vZGVfdHlwZSBkLCBpbnQgaWR4KQoreworCWJoX25vZGVpZHhfZW50cnkgKmVu dDsKKwlib29sCWZvdW5kOworCisJLyogU2V0IHRoZSBub2RlIHRvIHRoZSBub2RlcyBhcnJh eSAqLworCWhlYXAtPmJoX25vZGVzW2lkeF0gPSBkOworCisJaWYgKGhlYXAtPmJoX2luZGV4 ZWQpCisJeworCQkvKiBSZW1lbWJlciBpdHMgaW5kZXggaW4gdGhlIG5vZGVzIGFycmF5ICov CisJCWVudCA9IGJoX25vZGVpZHhfaW5zZXJ0KGhlYXAtPmJoX25vZGVpZHgsIGQsICZmb3Vu ZCk7CisJCWVudC0+aWR4ID0gaWR4OworCX0KK30KKworLyoKKyAqIFJlcGxhY2UgdGhlIG5v ZGUgYXQgJ2lkeCcgd2l0aCB0aGUgZ2l2ZW4gbm9kZSAncmVwbGFjZWRfYnknLiBBbHNvCisg KiB1cGRhdGUgdGhlaXIgcG9zaXRpb25zIGFjY29yZGluZ2x5LgorICovCitzdGF0aWMgdm9p ZAorYmhfcmVwbGFjZV9ub2RlKGJpbmFyeWhlYXAgKmhlYXAsIGludCBpZHgsIGJoX25vZGVf dHlwZSByZXBsYWNlZF9ieSkKK3sKKwliaF9ub2RlX3R5cGUJbm9kZSA9IGhlYXAtPmJoX25v ZGVzW2lkeF07CisKKwkvKiBSZW1vdmUgb3ZlcndyaXR0ZW4gbm9kZSdzIGluZGV4ICovCisJ aWYgKGhlYXAtPmJoX2luZGV4ZWQpCisJCSh2b2lkKSBiaF9ub2RlaWR4X2RlbGV0ZShoZWFw LT5iaF9ub2RlaWR4LCBub2RlKTsKKworCS8qIFJlcGxhY2UgaXQgd2l0aCB0aGUgZ2l2ZW4g bmV3IG5vZGUgKi8KKwlpZiAoaWR4IDwgaGVhcC0+Ymhfc2l6ZSkKKwkJYmhfc2V0X25vZGUo aGVhcCwgcmVwbGFjZWRfYnksIGlkeCk7Cit9CisKIC8qCiAgKiBiaW5hcnloZWFwX2FkZF91 bm9yZGVyZWQKICAqCkBAIC0xMzAsNyArMjA1LDcgQEAgYmluYXJ5aGVhcF9hZGRfdW5vcmRl cmVkKGJpbmFyeWhlYXAgKmhlYXAsIGJoX25vZGVfdHlwZSBkKQogCQliaF9lbmxhcmdlX25v ZGVfYXJyYXkoaGVhcCk7CiAKIAloZWFwLT5iaF9oYXNfaGVhcF9wcm9wZXJ0eSA9IGZhbHNl OwotCWhlYXAtPmJoX25vZGVzW2hlYXAtPmJoX3NpemVdID0gZDsKKwliaF9zZXRfbm9kZSho ZWFwLCBkLCBoZWFwLT5iaF9zaXplKTsKIAloZWFwLT5iaF9zaXplKys7CiB9CiAKQEAgLTE2 Myw3ICsyMzgsNyBAQCBiaW5hcnloZWFwX2FkZChiaW5hcnloZWFwICpoZWFwLCBiaF9ub2Rl X3R5cGUgZCkKIAlpZiAoaGVhcC0+Ymhfc2l6ZSA+PSBoZWFwLT5iaF9zcGFjZSkKIAkJYmhf ZW5sYXJnZV9ub2RlX2FycmF5KGhlYXApOwogCi0JaGVhcC0+Ymhfbm9kZXNbaGVhcC0+Ymhf c2l6ZV0gPSBkOworCWJoX3NldF9ub2RlKGhlYXAsIGQsIGhlYXAtPmJoX3NpemUpOwogCWhl YXAtPmJoX3NpemUrKzsKIAlzaWZ0X3VwKGhlYXAsIGhlYXAtPmJoX3NpemUgLSAxKTsKIH0K QEAgLTIwNCw2ICsyNzksMTAgQEAgYmluYXJ5aGVhcF9yZW1vdmVfZmlyc3QoYmluYXJ5aGVh cCAqaGVhcCkKIAlpZiAoaGVhcC0+Ymhfc2l6ZSA9PSAxKQogCXsKIAkJaGVhcC0+Ymhfc2l6 ZS0tOworCisJCWlmIChoZWFwLT5iaF9pbmRleGVkKQorCQkJYmhfbm9kZWlkeF9kZWxldGUo aGVhcC0+Ymhfbm9kZWlkeCwgcmVzdWx0KTsKKwogCQlyZXR1cm4gcmVzdWx0OwogCX0KIApA QCAtMjExLDcgKzI5MCw3IEBAIGJpbmFyeWhlYXBfcmVtb3ZlX2ZpcnN0KGJpbmFyeWhlYXAg KmhlYXApCiAJICogUmVtb3ZlIHRoZSBsYXN0IG5vZGUsIHBsYWNpbmcgaXQgaW4gdGhlIHZh Y2F0ZWQgcm9vdCBlbnRyeSwgYW5kIHNpZnQKIAkgKiB0aGUgbmV3IHJvb3Qgbm9kZSBkb3du IHRvIGl0cyBjb3JyZWN0IHBvc2l0aW9uLgogCSAqLwotCWhlYXAtPmJoX25vZGVzWzBdID0g aGVhcC0+Ymhfbm9kZXNbLS1oZWFwLT5iaF9zaXplXTsKKwliaF9yZXBsYWNlX25vZGUoaGVh cCwgMCwgaGVhcC0+Ymhfbm9kZXNbLS1oZWFwLT5iaF9zaXplXSk7CiAJc2lmdF9kb3duKGhl YXAsIDApOwogCiAJcmV0dXJuIHJlc3VsdDsKQEAgLTIzNyw3ICszMTYsNyBAQCBiaW5hcnlo ZWFwX3JlbW92ZV9ub2RlKGJpbmFyeWhlYXAgKmhlYXAsIGludCBuKQogCQkJCQkJICAgaGVh cC0+YmhfYXJnKTsKIAogCS8qIHJlbW92ZSB0aGUgbGFzdCBub2RlLCBwbGFjaW5nIGl0IGlu IHRoZSB2YWNhdGVkIGVudHJ5ICovCi0JaGVhcC0+Ymhfbm9kZXNbbl0gPSBoZWFwLT5iaF9u b2Rlc1toZWFwLT5iaF9zaXplXTsKKwliaF9yZXBsYWNlX25vZGUoaGVhcCwgbiwgaGVhcC0+ Ymhfbm9kZXNbaGVhcC0+Ymhfc2l6ZV0pOwogCiAJLyogc2lmdCBhcyBuZWVkZWQgdG8gcHJl c2VydmUgdGhlIGhlYXAgcHJvcGVydHkgKi8KIAlpZiAoY21wID4gMCkKQEAgLTI0Niw2ICsz MjUsNzQgQEAgYmluYXJ5aGVhcF9yZW1vdmVfbm9kZShiaW5hcnloZWFwICpoZWFwLCBpbnQg bikKIAkJc2lmdF9kb3duKGhlYXAsIG4pOwogfQogCisvKgorICogYmluYXJ5aGVhcF9yZW1v dmVfbm9kZV9wdHIKKyAqCisgKiBTaW1pbGFyIHRvIGJpbmFyeWhlYXBfcmVtb3ZlX25vZGUo KSBidXQgcmVtb3ZlcyB0aGUgZ2l2ZW4gbm9kZS4gVGhlIGNhbGxlcgorICogbXVzdCBlbnN1 cmUgdGhhdCB0aGUgZ2l2ZW4gbm9kZSBpcyBpbiB0aGUgaGVhcC4gTyhsb2cgbikgd29yc3Qg Y2FzZS4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGNhbiBiZSB1c2VkIG9ubHkgaWYgYmhfaW5k ZXhlZCBpcyB0cnVlLgorICovCit2b2lkCitiaW5hcnloZWFwX3JlbW92ZV9ub2RlX3B0cihi aW5hcnloZWFwICpoZWFwLCBiaF9ub2RlX3R5cGUgZCkKK3sKKwliaF9ub2RlaWR4X2VudHJ5 ICplbnQ7CisKKwlBc3NlcnQoIWJpbmFyeWhlYXBfZW1wdHkoaGVhcCkgJiYgaGVhcC0+Ymhf aGFzX2hlYXBfcHJvcGVydHkpOworCUFzc2VydChoZWFwLT5iaF9pbmRleGVkKTsKKworCWVu dCA9IGJoX25vZGVpZHhfbG9va3VwKGhlYXAtPmJoX25vZGVpZHgsIGQpOworCUFzc2VydChl bnQpOworCisJYmluYXJ5aGVhcF9yZW1vdmVfbm9kZShoZWFwLCBlbnQtPmlkeCk7Cit9CisK Ky8qCisgKiBiaW5hcnloZWFwX3VwZGF0ZV91cAorICoKKyAqIFNpZnQgdGhlIGdpdmVuIG5v ZGUgdXAgYWZ0ZXIgdGhlIG5vZGUncyBrZXkgaXMgdXBkYXRlZC4gVGhlIGNhbGxlciBtdXN0 CisgKiBlbnN1cmUgdGhhdCB0aGUgZ2l2ZW4gbm9kZSBpcyBpbiB0aGUgaGVhcC4gTyhsb2cg bikgd29yc3QgY2FzZS4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGNhbiBiZSB1c2VkIG9ubHkg aWYgYmhfaW5kZXhlZCBpcyB0cnVlLgorICovCit2b2lkCitiaW5hcnloZWFwX3VwZGF0ZV91 cChiaW5hcnloZWFwICpoZWFwLCBiaF9ub2RlX3R5cGUgZCkKK3sKKwliaF9ub2RlaWR4X2Vu dHJ5ICplbnQ7CisKKwlBc3NlcnQoIWJpbmFyeWhlYXBfZW1wdHkoaGVhcCkgJiYgaGVhcC0+ YmhfaGFzX2hlYXBfcHJvcGVydHkpOworCUFzc2VydChoZWFwLT5iaF9pbmRleGVkKTsKKwor CWVudCA9IGJoX25vZGVpZHhfbG9va3VwKGhlYXAtPmJoX25vZGVpZHgsIGQpOworCUFzc2Vy dChlbnQpOworCUFzc2VydChlbnQtPmlkeCA+PSAwICYmIGVudC0+aWR4IDwgaGVhcC0+Ymhf c2l6ZSk7CisKKwlzaWZ0X3VwKGhlYXAsIGVudC0+aWR4KTsKK30KKworLyoKKyAqIGJpbmFy eWhlYXBfdXBkYXRlX2Rvd24KKyAqCisgKiBTaWZ0IHRoZSBnaXZlbiBub2RlIGRvd24gYWZ0 ZXIgdGhlIG5vZGUncyBrZXkgaXMgdXBkYXRlZC4gVGhlIGNhbGxlciBtdXN0CisgKiBlbnN1 cmUgdGhhdCB0aGUgZ2l2ZW4gbm9kZSBpcyBpbiB0aGUgaGVhcC4gTyhsb2cgbikgd29yc3Qg Y2FzZS4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGNhbiBiZSB1c2VkIG9ubHkgaWYgYmhfaW5k ZXhlZCBpcyB0cnVlLgorICovCit2b2lkCitiaW5hcnloZWFwX3VwZGF0ZV9kb3duKGJpbmFy eWhlYXAgKmhlYXAsIGJoX25vZGVfdHlwZSBkKQoreworCWJoX25vZGVpZHhfZW50cnkgKmVu dDsKKworCUFzc2VydCghYmluYXJ5aGVhcF9lbXB0eShoZWFwKSAmJiBoZWFwLT5iaF9oYXNf aGVhcF9wcm9wZXJ0eSk7CisJQXNzZXJ0KGhlYXAtPmJoX2luZGV4ZWQpOworCisJZW50ID0g Ymhfbm9kZWlkeF9sb29rdXAoaGVhcC0+Ymhfbm9kZWlkeCwgZCk7CisJQXNzZXJ0KGVudCk7 CisJQXNzZXJ0KGVudC0+aWR4ID49IDAgJiYgZW50LT5pZHggPCBoZWFwLT5iaF9zaXplKTsK KworCXNpZnRfZG93bihoZWFwLCBlbnQtPmlkeCk7Cit9CisKIC8qCiAgKiBiaW5hcnloZWFw X3JlcGxhY2VfZmlyc3QKICAqCkBAIC0yNTgsNyArNDA1LDcgQEAgYmluYXJ5aGVhcF9yZXBs YWNlX2ZpcnN0KGJpbmFyeWhlYXAgKmhlYXAsIGJoX25vZGVfdHlwZSBkKQogewogCUFzc2Vy dCghYmluYXJ5aGVhcF9lbXB0eShoZWFwKSAmJiBoZWFwLT5iaF9oYXNfaGVhcF9wcm9wZXJ0 eSk7CiAKLQloZWFwLT5iaF9ub2Rlc1swXSA9IGQ7CisJYmhfcmVwbGFjZV9ub2RlKGhlYXAs IDAsIGQpOwogCiAJaWYgKGhlYXAtPmJoX3NpemUgPiAxKQogCQlzaWZ0X2Rvd24oaGVhcCwg MCk7CkBAIC0zMDAsMTEgKzQ0NywxMSBAQCBzaWZ0X3VwKGJpbmFyeWhlYXAgKmhlYXAsIGlu dCBub2RlX29mZikKIAkJICogT3RoZXJ3aXNlLCBzd2FwIHRoZSBwYXJlbnQgdmFsdWUgd2l0 aCB0aGUgaG9sZSwgYW5kIGdvIG9uIHRvIGNoZWNrCiAJCSAqIHRoZSBub2RlJ3MgbmV3IHBh cmVudC4KIAkJICovCi0JCWhlYXAtPmJoX25vZGVzW25vZGVfb2ZmXSA9IHBhcmVudF92YWw7 CisJCWJoX3NldF9ub2RlKGhlYXAsIHBhcmVudF92YWwsIG5vZGVfb2ZmKTsKIAkJbm9kZV9v ZmYgPSBwYXJlbnRfb2ZmOwogCX0KIAkvKiBSZS1maWxsIHRoZSBob2xlICovCi0JaGVhcC0+ Ymhfbm9kZXNbbm9kZV9vZmZdID0gbm9kZV92YWw7CisJYmhfc2V0X25vZGUoaGVhcCwgbm9k ZV92YWwsIG5vZGVfb2ZmKTsKIH0KIAogLyoKQEAgLTM1OSw5ICs1MDYsOSBAQCBzaWZ0X2Rv d24oYmluYXJ5aGVhcCAqaGVhcCwgaW50IG5vZGVfb2ZmKQogCQkgKiBPdGhlcndpc2UsIHN3 YXAgdGhlIGhvbGUgd2l0aCB0aGUgY2hpbGQgdGhhdCB2aW9sYXRlcyB0aGUgaGVhcAogCQkg KiBwcm9wZXJ0eTsgdGhlbiBnbyBvbiB0byBjaGVjayBpdHMgY2hpbGRyZW4uCiAJCSAqLwot CQloZWFwLT5iaF9ub2Rlc1tub2RlX29mZl0gPSBoZWFwLT5iaF9ub2Rlc1tzd2FwX29mZl07 CisJCWJoX3NldF9ub2RlKGhlYXAsIGhlYXAtPmJoX25vZGVzW3N3YXBfb2ZmXSwgbm9kZV9v ZmYpOwogCQlub2RlX29mZiA9IHN3YXBfb2ZmOwogCX0KIAkvKiBSZS1maWxsIHRoZSBob2xl ICovCi0JaGVhcC0+Ymhfbm9kZXNbbm9kZV9vZmZdID0gbm9kZV92YWw7CisJYmhfc2V0X25v ZGUoaGVhcCwgbm9kZV92YWwsIG5vZGVfb2ZmKTsKIH0KZGlmZiAtLWdpdCBhL3NyYy9pbmNs dWRlL2xpYi9iaW5hcnloZWFwLmggYi9zcmMvaW5jbHVkZS9saWIvYmluYXJ5aGVhcC5oCmlu ZGV4IDE0MzlmMjA4MDMzLi40OGMyZGUzM2I0OCAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUv bGliL2JpbmFyeWhlYXAuaAorKysgYi9zcmMvaW5jbHVkZS9saWIvYmluYXJ5aGVhcC5oCkBA IC0yOSw2ICsyOSwyOCBAQCB0eXBlZGVmIERhdHVtIGJoX25vZGVfdHlwZTsKICAqLwogdHlw ZWRlZiBpbnQgKCpiaW5hcnloZWFwX2NvbXBhcmF0b3IpIChiaF9ub2RlX3R5cGUgYSwgYmhf bm9kZV90eXBlIGIsIHZvaWQgKmFyZyk7CiAKKy8qCisgKiBTdHJ1Y3QgZm9yIEEgaGFzaCB0 YWJsZSBlbGVtZW50IHRvIHN0b3JlIHRoZSBub2RlJ3MgaW5kZXggaW4gdGhlIGJoX25vZGVz CisgKiBhcnJheS4KKyAqLwordHlwZWRlZiBzdHJ1Y3QgYmhfbm9kZWlkeF9lbnRyeQorewor CWJoX25vZGVfdHlwZQlrZXk7CisJY2hhcgkJCXN0YXR1czsKKwlpbnQJCQkJaWR4OworfSBi aF9ub2RlaWR4X2VudHJ5OworCisvKiBkZWZpbmUgcGFyYW1ldGVycyBuZWNlc3NhcnkgdG8g Z2VuZXJhdGUgdGhlIGhhc2ggdGFibGUgaW50ZXJmYWNlICovCisjZGVmaW5lIFNIX1BSRUZJ WCBiaF9ub2RlaWR4CisjZGVmaW5lIFNIX0VMRU1FTlRfVFlQRSBiaF9ub2RlaWR4X2VudHJ5 CisjZGVmaW5lIFNIX0tFWV9UWVBFIGJoX25vZGVfdHlwZQorI2RlZmluZSBTSF9TQ09QRSBl eHRlcm4KKyNpZmRlZiBGUk9OVEVORAorI2RlZmluZSBTSF9SQVdfQUxMT0NBVE9SIHBnX21h bGxvYzAKKyNlbmRpZgorI2RlZmluZSBTSF9ERUNMQVJFCisjaW5jbHVkZSAibGliL3NpbXBs ZWhhc2guaCIKKwogLyoKICAqIGJpbmFyeWhlYXAKICAqCkBAIC00NywxMSArNjksMTkgQEAg dHlwZWRlZiBzdHJ1Y3QgYmluYXJ5aGVhcAogCWJpbmFyeWhlYXBfY29tcGFyYXRvciBiaF9j b21wYXJlOwogCXZvaWQJICAgKmJoX2FyZzsKIAliaF9ub2RlX3R5cGUgKmJoX25vZGVzOwor CisJLyoKKwkgKiBJZiBiaF9pbmRleGVkIGlzIHRydWUsIHRoZSBiaF9ub2RlaWR4IGlzIHVz ZWQgdG8gdHJhY2sgb2YgZWFjaAorCSAqIG5vZGUncyBpbmRleCBpbiBiaF9ub2Rlcy4gVGhp cyBlbmFibGVzIHRoZSBjYWxsZXIgdG8gcGVyZm9ybQorCSAqIGJpbmFyeWhlYXBfcmVtb3Zl X25vZGVfcHRyKCksIGJpbmFyeWhlYXBfdXBkYXRlX3VwL2Rvd24gaW4gTyhsb2cgbikuCisJ ICovCisJYm9vbAkJYmhfaW5kZXhlZDsKKwliaF9ub2RlaWR4X2hhc2gJKmJoX25vZGVpZHg7 CiB9IGJpbmFyeWhlYXA7CiAKIGV4dGVybiBiaW5hcnloZWFwICpiaW5hcnloZWFwX2FsbG9j YXRlKGludCBjYXBhY2l0eSwKIAkJCQkJCQkJCSAgIGJpbmFyeWhlYXBfY29tcGFyYXRvciBj b21wYXJlLAotCQkJCQkJCQkJICAgdm9pZCAqYXJnKTsKKwkJCQkJCQkJCSAgIGJvb2wgaW5k ZXhlZCwgdm9pZCAqYXJnKTsKIGV4dGVybiB2b2lkIGJpbmFyeWhlYXBfcmVzZXQoYmluYXJ5 aGVhcCAqaGVhcCk7CiBleHRlcm4gdm9pZCBiaW5hcnloZWFwX2ZyZWUoYmluYXJ5aGVhcCAq aGVhcCk7CiBleHRlcm4gdm9pZCBiaW5hcnloZWFwX2FkZF91bm9yZGVyZWQoYmluYXJ5aGVh cCAqaGVhcCwgYmhfbm9kZV90eXBlIGQpOwpAQCAtNjAsNyArOTAsMTAgQEAgZXh0ZXJuIHZv aWQgYmluYXJ5aGVhcF9hZGQoYmluYXJ5aGVhcCAqaGVhcCwgYmhfbm9kZV90eXBlIGQpOwog ZXh0ZXJuIGJoX25vZGVfdHlwZSBiaW5hcnloZWFwX2ZpcnN0KGJpbmFyeWhlYXAgKmhlYXAp OwogZXh0ZXJuIGJoX25vZGVfdHlwZSBiaW5hcnloZWFwX3JlbW92ZV9maXJzdChiaW5hcnlo ZWFwICpoZWFwKTsKIGV4dGVybiB2b2lkIGJpbmFyeWhlYXBfcmVtb3ZlX25vZGUoYmluYXJ5 aGVhcCAqaGVhcCwgaW50IG4pOworZXh0ZXJuIHZvaWQgYmluYXJ5aGVhcF9yZW1vdmVfbm9k ZV9wdHIoYmluYXJ5aGVhcCAqaGVhcCwgYmhfbm9kZV90eXBlIGQpOwogZXh0ZXJuIHZvaWQg YmluYXJ5aGVhcF9yZXBsYWNlX2ZpcnN0KGJpbmFyeWhlYXAgKmhlYXAsIGJoX25vZGVfdHlw ZSBkKTsKK2V4dGVybiB2b2lkIGJpbmFyeWhlYXBfdXBkYXRlX3VwKGJpbmFyeWhlYXAgKmhl YXAsIGJoX25vZGVfdHlwZSBkKTsKK2V4dGVybiB2b2lkIGJpbmFyeWhlYXBfdXBkYXRlX2Rv d24oYmluYXJ5aGVhcCAqaGVhcCwgYmhfbm9kZV90eXBlIGQpOwogCiAjZGVmaW5lIGJpbmFy eWhlYXBfZW1wdHkoaCkJCQkoKGgpLT5iaF9zaXplID09IDApCiAjZGVmaW5lIGJpbmFyeWhl YXBfc2l6ZShoKQkJCSgoaCktPmJoX3NpemUpCi0tIAoyLjQzLjAKCg== --------------9aa4PS6RDhvp5jfrDfxgDS8r Content-Type: text/x-patch; charset=UTF-8; name="v5-0001-Make-binaryheap-enlareable.patch" Content-Disposition: attachment; filename="v5-0001-Make-binaryheap-enlareable.patch" Content-Transfer-Encoding: base64 RnJvbSA1NDBiZmE1NTY4ZWUwNzIwNWJjM2UxOGFhZWM3OGUwMmVmMjA1MWMwIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYXNhaGlrbyBTYXdhZGEgPHNhd2FkYS5tc2hrQGdt YWlsLmNvbT4KRGF0ZTogRnJpLCAyNiBKYW4gMjAyNCAxNzoxMjoyMCArMDkwMApTdWJqZWN0 OiBbUEFUQ0ggdjUgMS81XSBNYWtlIGJpbmFyeWhlYXAgZW5sYXJlYWJsZS4KCkF1dGhvcjoK UmV2aWV3ZWQtYnk6CkRpc2N1c3Npb246IGh0dHBzOi8vcG9zdGdyLmVzL20vCkJhY2twYXRj aC10aHJvdWdoOgotLS0KIHNyYy9jb21tb24vYmluYXJ5aGVhcC5jICAgICAgfCAzNiArKysr KysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0KIHNyYy9pbmNsdWRlL2xpYi9iaW5h cnloZWFwLmggfCAgMiArLQogMiBmaWxlcyBjaGFuZ2VkLCAyMCBpbnNlcnRpb25zKCspLCAx OCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvY29tbW9uL2JpbmFyeWhlYXAuYyBi L3NyYy9jb21tb24vYmluYXJ5aGVhcC5jCmluZGV4IDczNzdlYmRmMTU2Li42ZjE2YzgzMjk1 ZCAxMDA2NDQKLS0tIGEvc3JjL2NvbW1vbi9iaW5hcnloZWFwLmMKKysrIGIvc3JjL2NvbW1v bi9iaW5hcnloZWFwLmMKQEAgLTM4LDE3ICszOCwxNiBAQCBzdGF0aWMgdm9pZCBzaWZ0X3Vw KGJpbmFyeWhlYXAgKmhlYXAsIGludCBub2RlX29mZik7CiBiaW5hcnloZWFwICoKIGJpbmFy eWhlYXBfYWxsb2NhdGUoaW50IGNhcGFjaXR5LCBiaW5hcnloZWFwX2NvbXBhcmF0b3IgY29t cGFyZSwgdm9pZCAqYXJnKQogewotCWludAkJCXN6OwogCWJpbmFyeWhlYXAgKmhlYXA7CiAK LQlzeiA9IG9mZnNldG9mKGJpbmFyeWhlYXAsIGJoX25vZGVzKSArIHNpemVvZihiaF9ub2Rl X3R5cGUpICogY2FwYWNpdHk7Ci0JaGVhcCA9IChiaW5hcnloZWFwICopIHBhbGxvYyhzeik7 CisJaGVhcCA9IChiaW5hcnloZWFwICopIHBhbGxvYyhzaXplb2YoYmluYXJ5aGVhcCkpOwog CWhlYXAtPmJoX3NwYWNlID0gY2FwYWNpdHk7CiAJaGVhcC0+YmhfY29tcGFyZSA9IGNvbXBh cmU7CiAJaGVhcC0+YmhfYXJnID0gYXJnOwogCiAJaGVhcC0+Ymhfc2l6ZSA9IDA7CiAJaGVh cC0+YmhfaGFzX2hlYXBfcHJvcGVydHkgPSB0cnVlOworCWhlYXAtPmJoX25vZGVzID0gKGJo X25vZGVfdHlwZSAqKSBwYWxsb2Moc2l6ZW9mKGJoX25vZGVfdHlwZSkgKiBjYXBhY2l0eSk7 CiAKIAlyZXR1cm4gaGVhcDsKIH0KQEAgLTEwNCw2ICsxMDMsMTcgQEAgcGFyZW50X29mZnNl dChpbnQgaSkKIAlyZXR1cm4gKGkgLSAxKSAvIDI7CiB9CiAKKy8qCisgKiBNYWtlIHN1cmUg dGhlcmUgaXMgZW5vdWdoIHNwYWNlIGZvciBub2Rlcy4KKyAqLworc3RhdGljIHZvaWQKK2Jo X2VubGFyZ2Vfbm9kZV9hcnJheShiaW5hcnloZWFwICpoZWFwKQoreworCWhlYXAtPmJoX3Nw YWNlICo9IDI7CisJaGVhcC0+Ymhfbm9kZXMgPSByZXBhbGxvYyhoZWFwLT5iaF9ub2RlcywK KwkJCQkJCQkgIHNpemVvZihiaF9ub2RlX3R5cGUpICogaGVhcC0+Ymhfc3BhY2UpOworfQor CiAvKgogICogYmluYXJ5aGVhcF9hZGRfdW5vcmRlcmVkCiAgKgpAQCAtMTE1LDE0ICsxMjUs MTAgQEAgcGFyZW50X29mZnNldChpbnQgaSkKIHZvaWQKIGJpbmFyeWhlYXBfYWRkX3Vub3Jk ZXJlZChiaW5hcnloZWFwICpoZWFwLCBiaF9ub2RlX3R5cGUgZCkKIHsKKwkvKiBtYWtlIHN1 cmUgZW5vdWdoIHNwYWNlIGZvciBhIG5ldyBub2RlICovCiAJaWYgKGhlYXAtPmJoX3NpemUg Pj0gaGVhcC0+Ymhfc3BhY2UpCi0JewotI2lmZGVmIEZST05URU5ECi0JCXBnX2ZhdGFsKCJv dXQgb2YgYmluYXJ5IGhlYXAgc2xvdHMiKTsKLSNlbHNlCi0JCWVsb2coRVJST1IsICJvdXQg b2YgYmluYXJ5IGhlYXAgc2xvdHMiKTsKLSNlbmRpZgotCX0KKwkJYmhfZW5sYXJnZV9ub2Rl X2FycmF5KGhlYXApOworCiAJaGVhcC0+YmhfaGFzX2hlYXBfcHJvcGVydHkgPSBmYWxzZTsK IAloZWFwLT5iaF9ub2Rlc1toZWFwLT5iaF9zaXplXSA9IGQ7CiAJaGVhcC0+Ymhfc2l6ZSsr OwpAQCAtMTUzLDE0ICsxNTksMTAgQEAgYmluYXJ5aGVhcF9idWlsZChiaW5hcnloZWFwICpo ZWFwKQogdm9pZAogYmluYXJ5aGVhcF9hZGQoYmluYXJ5aGVhcCAqaGVhcCwgYmhfbm9kZV90 eXBlIGQpCiB7CisJLyogbWFrZSBzdXJlIGVub3VnaCBzcGFjZSBmb3IgYSBuZXcgbm9kZSAq LwogCWlmIChoZWFwLT5iaF9zaXplID49IGhlYXAtPmJoX3NwYWNlKQotCXsKLSNpZmRlZiBG Uk9OVEVORAotCQlwZ19mYXRhbCgib3V0IG9mIGJpbmFyeSBoZWFwIHNsb3RzIik7Ci0jZWxz ZQotCQllbG9nKEVSUk9SLCAib3V0IG9mIGJpbmFyeSBoZWFwIHNsb3RzIik7Ci0jZW5kaWYK LQl9CisJCWJoX2VubGFyZ2Vfbm9kZV9hcnJheShoZWFwKTsKKwogCWhlYXAtPmJoX25vZGVz W2hlYXAtPmJoX3NpemVdID0gZDsKIAloZWFwLT5iaF9zaXplKys7CiAJc2lmdF91cChoZWFw LCBoZWFwLT5iaF9zaXplIC0gMSk7CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9saWIvYmlu YXJ5aGVhcC5oIGIvc3JjL2luY2x1ZGUvbGliL2JpbmFyeWhlYXAuaAppbmRleCAxOTAyNWMw OGVmMS4uMTQzOWYyMDgwMzMgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL2xpYi9iaW5hcnlo ZWFwLmgKKysrIGIvc3JjL2luY2x1ZGUvbGliL2JpbmFyeWhlYXAuaApAQCAtNDYsNyArNDYs NyBAQCB0eXBlZGVmIHN0cnVjdCBiaW5hcnloZWFwCiAJYm9vbAkJYmhfaGFzX2hlYXBfcHJv cGVydHk7CS8qIGRlYnVnZ2luZyBjcm9zcy1jaGVjayAqLwogCWJpbmFyeWhlYXBfY29tcGFy YXRvciBiaF9jb21wYXJlOwogCXZvaWQJICAgKmJoX2FyZzsKLQliaF9ub2RlX3R5cGUgYmhf bm9kZXNbRkxFWElCTEVfQVJSQVlfTUVNQkVSXTsKKwliaF9ub2RlX3R5cGUgKmJoX25vZGVz OwogfSBiaW5hcnloZWFwOwogCiBleHRlcm4gYmluYXJ5aGVhcCAqYmluYXJ5aGVhcF9hbGxv Y2F0ZShpbnQgY2FwYWNpdHksCi0tIAoyLjQzLjAKCg== --------------9aa4PS6RDhvp5jfrDfxgDS8r Content-Type: application/x-compressed-tar; name="test-scripts.tgz" Content-Disposition: attachment; filename="test-scripts.tgz" Content-Transfer-Encoding: base64 H4sIAAAAAAAAA+2ZW3PqNhDH8xp/iu0cpkAnBN/dGXrOQ9/bh17eOsMII4wmRvKRZJLTy3ev ZBuHa4BMIU27v4cA9nq1UrT/Xdup4Kpc0IHKhb5Xn/ObC+Aa4jCsPj033visvifBjRdGcewF URwGN6754Sc34F4imG1KpYkEuCmE0pmk6pDdsfPvFEU15CJjKcnHU5qKKePZ+FHIh/GCLkAL 6IY/fN8dOc5vmi3MORDccRTNaaohFSXXvW/6MJNiAUU2Xjmym2lcUPowTueEZ1T1uvZQ9w54 mef1377z1lNHDDmRGb1U4jccy/8oXMv/wOZ/4CUe5v81aFLZJO9UimIsaZGbFNZM8CqLm8Tt j9qkN5appETTNtsPXHMHXU2VblWlcmIHAU0mOQU2A/rElFZgzcy52m1z1h6DXgqMa3sd44pK bX+J+lQTDau1J6OcShuTsWJGbrw7r95afVA9VkePOrcPSetlv2QDcLT+R3GT/34UJrGt/3EU Yv5fg+vm/1vPFtlGlZMnkuqBWpA8f6P8j02xb+p/7MdRlf+xj/l/DU7P/9eW7uackGCdk5TC rOSpHaGynHFjy6vS3jcWupRcwVKwKRAFnY4zoRnjDsDMOGDGCrz7e2ufC1GYwwArA8tOm7Ak eUkVVD2ANaBPKS2qsR/nlMOULZmyc518Gf9OpbnIHG18ScIUBS40MyF3U1Jmcw1USiG7o5VJ FW7jmU/tF/NRhTZyqgNmArnpDEqSUSjyIjMJ9u+S0ib/L3oHcCT/Pc+L2v4/cav+Pwox/6/C O+n/UUQOiUg9/V59v4N3Osh52O1z4cc/R/s/1w+f+78ksfrvRhHq/zXYUhH/W7xL+18hS+7f q/lFx7ApnrzQ/wVe+/w3cT37/MePEuz/rsKHr4alksMJ40PKlzAhau44P/36488fXcf5AFoS rkjdaD0yPYcF4V+guWlQjtM2VJ2eop/Bg469tj+CqXCc243rVe2AwMR0bnMQs2c3t4WpQHWv 9R3sPJGATzCc0uXQ9hjgf/raM56LbEKtlwGHQQpxCAMNtgWCwQxWJa12uOdi/bHTWx8x3XoH WtnBn2D+3QX8whbUfCePD9D9o5CmK4SO/1e379zSdC7aOdThmuVRmkroMOho0+0KTpvVjI6s FTScumQr+2oegwKiMAhOX0F4HnB9JRs3Z6/oyle7sFsBvW6BV173rXNBdDqn042FfutUepcY /b+0/B/Tfz9I2uf/iecHlf77Lur/NTis/9E/rP/7rt+R4rXHUa9R4S39NQEYYYDqHfd6KLvj tq/Bzxm19rszZD3FSqbWtXytaDEYKCOuB+R0oxruvJ/bZ7/yu6Hbl61+m+J8sPadX/P2bZNj 9eXsXbO3tGwXlefw9m+iY1Gduac2YqpHOxjQoS22U9RXFf3lHfdSM3HCBjw46in78Rq9A7YM CIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIL8h/gbJLY97ABQAAA= --------------9aa4PS6RDhvp5jfrDfxgDS8r--