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 1rhApm-00A053-AD for pgsql-hackers@arkaria.postgresql.org; Mon, 04 Mar 2024 16:06:35 +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 1rhApk-009FFn-EA for pgsql-hackers@arkaria.postgresql.org; Mon, 04 Mar 2024 16:06:32 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1rhApj-009FFf-RH for pgsql-hackers@lists.postgresql.org; Mon, 04 Mar 2024 16:06:32 +0000 Received: from mail-lf1-x12c.google.com ([2a00:1450:4864:20::12c]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.94.2) (envelope-from ) id 1rhApe-002p27-94 for pgsql-hackers@lists.postgresql.org; Mon, 04 Mar 2024 16:06:30 +0000 Received: by mail-lf1-x12c.google.com with SMTP id 2adb3069b0e04-513298d6859so4307762e87.3 for ; Mon, 04 Mar 2024 08:06:27 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=enterprisedb.com; s=google; t=1709568385; x=1710173185; 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=Ithr4YYJs1geIX55q/zJJB3c/xvwKhxPEDphX/gMTzo=; b=Yb0Rjrc3eYxfcBKTcgDvadWux1rdeezzWaWIJcnIpgztcQyjfKhvdtP0GrycwMqkpH oQSlQNY21hkCmZCvuCJNDO794pZacx1Ovy+QaRZLWtVRZ+tKZUmRtM6oPKRiK1WPAiTd tV9/UZVhMOVppF/NYsNKoB4fLGisVJDnxV1bMRCUYFUnz9dlzMjTCC19k8tGIKXWLoby D27+CjK3n0x8aT5vKylcPHOUHuw5U8wP8lVc5Vz6yWBXfkx5knlzjV3jghWrIGx23w1w ybUIQg0Xk9Qc23/ZHZl8Do8vqYbLYYf9H+kDn7IBTqcLZijrN55M2Z1k5C26n4MfdhGK ipVQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1709568385; x=1710173185; 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=Ithr4YYJs1geIX55q/zJJB3c/xvwKhxPEDphX/gMTzo=; b=PzATEF3LgjDk3p4b11OBh7Ml6ZDuaORoyFs4/fBN/O00eDpf/FYIxtQ0Fl95x9DIQY OY9+HRK7NrPwbyHMAQPGvdANuUOEy2gs0+fysuoJNejtNIgx5eau94JEqb5/MCDW1aHT 35ldwNacRQYFjblBKv6gnXmOhuUZnYHDrBJXFN/afDPT1iuAcvVK1Ys1Be0EEaJojcu3 IWn1Y8ElGxzSlrn7zRvbAzG9qVH7U6vExqGuWUTAGMXxXtQSdl/SbVkQ2ZlDxGhn/gTd dvKSi1M6ldYlDVLkWxkHXcNvw+T/4OGkrCUzU1gIwjrfhKmPB8fLT+WCajvmA5O7goBj uClA== X-Forwarded-Encrypted: i=1; AJvYcCX/k1rzjNoBnyNg+JA/CGcjwRSVGG6CNdFWKgQBiBx8QOekJ61fNUs3J6SViCBHG2YTAvbJnRZCsv2xmmgIMUYf94BuFIlNlLu5el2rZBCTvlHO X-Gm-Message-State: AOJu0YyCEWUczf5qSJl3vxtYQwXB0hO5DgODs96B7uB0Q+HAmWGI/vJh a/0zmpBNM2gv6HmayfQ57QPMh9goD81XLxtDU4WQ9GwwemJIGxKqtpL7jc1W4g== X-Google-Smtp-Source: AGHT+IGFrf8nmq4j3wekXyDH5cTeN/QPkmYB0R+jRQj4sVuojl10VPdohJib8b3pZ9TUhHHxnff8zg== X-Received: by 2002:a05:6512:68d:b0:513:3dd4:182b with SMTP id t13-20020a056512068d00b005133dd4182bmr4660250lfe.10.1709568385448; Mon, 04 Mar 2024 08:06:25 -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 v29-20020a50a45d000000b005649f17558bsm5012853edb.42.2024.03.04.08.06.24 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 04 Mar 2024 08:06:25 -0800 (PST) Content-Type: multipart/mixed; boundary="------------jgXE3gDwRNJy5LoLC9WTGVCz" Message-ID: Date: Mon, 4 Mar 2024 17:06:23 +0100 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: Shared detoast Datum proposal To: Andy Fan Cc: Nikita Malakhov , Michael Zhilin , Peter Smith , vignesh C , Matthias van de Meent , pgsql-hackers@lists.postgresql.org References: <87il4jrk1l.fsf@163.com> <87h6jxw41k.fsf@163.com> <87sf3andy2.fsf@163.com> <87wmskm9qu.fsf@163.com> <87v87kvboq.fsf@163.com> <71321d83-391b-473b-aaf6-618c7f682b96@postgrespro.ru> <87r0i7vos3.fsf@163.com> <874je3hcwn.fsf@163.com> <8734tmg88e.fsf@163.com> <7f4c8673-4c5d-4dbf-b8e5-0ec11cd2fba0@enterprisedb.com> <87h6i2djf9.fsf@163.com> <87jzms0xza.fsf@163.com> <87frxf1gld.fsf@163.com> <875xyb1a6q.fsf@163.com> <87zfvedbsr.fsf@163.com> Content-Language: en-US From: Tomas Vondra In-Reply-To: <87zfvedbsr.fsf@163.com> 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. --------------jgXE3gDwRNJy5LoLC9WTGVCz Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit On 3/4/24 02:23, Andy Fan wrote: > > Tomas Vondra writes: > >> On 2/26/24 16:29, Andy Fan wrote: >>> >>> ...> >>> I can understand the benefits of the TOAST cache, but the following >>> issues looks not good to me IIUC: >>> >>> 1). we can't put the result to tts_values[*] since without the planner >>> decision, we don't know if this will break small_tlist logic. But if we >>> put it into the cache only, which means a cache-lookup as a overhead is >>> unavoidable. >> >> True - if you're comparing having the detoasted value in tts_values[*] >> directly with having to do a lookup in a cache, then yes, there's a bit >> of an overhead. >> >> But I think from the discussion it's clear having to detoast the value >> into tts_values[*] has some weaknesses too, in particular: >> >> - It requires decisions which attributes to detoast eagerly, which is >> quite invasive (having to walk the plan, ...). >> >> - I'm sure there will be cases where we choose to not detoast, but it >> would be beneficial to detoast. >> >> - Detoasting just the initial slices does not seem compatible with this. >> >> IMHO the overhead of the cache lookup would be negligible compared to >> the repeated detoasting of the value (which is the current baseline). I >> somewhat doubt the difference compared to tts_values[*] will be even >> measurable. >> >>> >>> 2). It is hard to decide which entry should be evicted without attaching >>> it to the TupleTableSlot's life-cycle. then we can't grantee the entry >>> we keep is the entry we will reuse soon? >>> >> >> True. But is that really a problem? I imagined we'd set some sort of >> memory limit on the cache (work_mem?), and evict oldest entries. So the >> entries would eventually get evicted, and the memory limit would ensure >> we don't consume arbitrary amounts of memory. >> > > Here is a copy from the shared_detoast_datum.org in the patch. I am > feeling about when / which entry to free is a key problem and run-time > (detoast_attr) overhead vs createplan.c overhead is a small difference > as well. the overhead I paid for createplan.c/setref.c looks not huge as > well. I decided to whip up a PoC patch implementing this approach, to get a better idea of how it compares to the original proposal, both in terms of performance and code complexity. Attached are two patches that both add a simple cache in detoast.c, but differ in when exactly the caching happens. toast-cache-v1 - caching happens in toast_fetch_datum, which means this happens before decompression toast-cache-v2 - caching happens in detoast_attr, after decompression I started with v1, but that did not help with the example workloads (from the original post) at all. Only after I changed this to cache decompressed data (in v2) it became competitive. There's GUC to enable the cache (enable_toast_cache, off by default), to make experimentation easier. The cache is invalidated at the end of a transaction - I think this should be OK, because the rows may be deleted but can't be cleaned up (or replaced with a new TOAST value). This means the cache could cover multiple queries - not sure if that's a good thing or bad thing. I haven't implemented any sort of cache eviction. I agree that's a hard problem in general, but I doubt we can do better than LRU. I also didn't implement any memory limit. FWIW I think it's a fairly serious issue Andy's approach does not have any way to limit the memory. It will detoasts the values eagerly, but what if the rows have multiple large values? What if we end up keeping multiple such rows (from different parts of the plan) at once? I also haven't implemented caching for sliced data. I think modifying the code to support this should not be difficult - it'd require tracking how much data we have in the cache, and considering that during lookup and when adding entries to cache. I've implemented the cache as "global". Maybe it should be tied to query or executor state, but then it'd be harder to access it from detoast.c (we'd have to pass the cache pointer in some way, and it wouldn't work for use cases that don't go through executor). I think implementation-wise this is pretty non-invasive. Performance-wise, these patches are slower than with Andy's patch. For example for the jsonb Q1, I see master ~500ms, Andy's patch ~100ms and v2 at ~150ms. I'm sure there's a number of optimization opportunities and v2 could get v2 closer to the 100ms. v1 is not competitive at all in this jsonb/Q1 test - it's just as slow as master, because the data set is small enough to be fully cached, so there's no I/O and it's the decompression is the actual bottleneck. That being said, I'm not convinced v1 would be a bad choice for some cases. If there's memory pressure enough to evict TOAST, it's quite possible the I/O would become the bottleneck. At which point it might be a good trade off to cache compressed data, because then we'd cache more detoasted values. OTOH it's likely the access to TOAST values is localized (in temporal sense), i.e. we read it from disk, detoast it a couple times in a short time interval, and then move to the next row. That'd mean v2 is probably the correct trade off. Not sure. > > """ > A alternative design: toast cache > --------------------------------- > > This method is provided by Tomas during the review process. IIUC, this > method would maintain a local HTAB which map a toast datum to a detoast > datum and the entry is maintained / used in detoast_attr > function. Within this method, the overall design is pretty clear and the > code modification can be controlled in toasting system only. > Right. > I assumed that releasing all of the memory at the end of executor once > is not an option since it may consumed too many memory. Then, when and > which entry to release becomes a trouble for me. For example: > > QUERY PLAN > ------------------------------ > Nested Loop > Join Filter: (t1.a = t2.a) > -> Seq Scan on t1 > -> Seq Scan on t2 > (4 rows) > > In this case t1.a needs a longer lifespan than t2.a since it is > in outer relation. Without the help from slot's life-cycle system, I > can't think out a answer for the above question. > This is true, but how likely such plans are? I mean, surely no one would do nested loop with sequential scans on reasonably large tables, so how representative this example is? Also, this leads me to the need of having some sort of memory limit. If we may be keeping entries for extended periods of time, and we don't have any way to limit the amount of memory, that does not seem great. AFAIK if we detoast everything into tts_values[] there's no way to implement and enforce such limit. What happens if there's a row with multiple large-ish TOAST values? What happens if those rows are in different (and distant) parts of the plan? It seems far easier to limit the memory with the toast cache. > Another difference between the 2 methods is my method have many > modification on createplan.c/setref.c/execExpr.c/execExprInterp.c, but > it can save some run-time effort like hash_search find / enter run-time > in method 2 since I put them directly into tts_values[*]. > > I'm not sure the factor 2 makes some real measurable difference in real > case, so my current concern mainly comes from factor 1. > """ > This seems a bit dismissive of the (possible) issue. It'd be good to do some measurements, especially on simple queries that can't benefit from the detoasting (e.g. because there's no varlena attribute). In any case, my concern is more about having to do this when creating the plan at all, the code complexity etc. Not just because it might have performance impact. regards -- Tomas Vondra EnterpriseDB: http://www.enterprisedb.com The Enterprise PostgreSQL Company --------------jgXE3gDwRNJy5LoLC9WTGVCz Content-Type: text/x-patch; charset=UTF-8; name="toast-cache-v1.patch" Content-Disposition: attachment; filename="toast-cache-v1.patch" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9jb21tb24vZGV0b2FzdC5jIGIvc3Jj L2JhY2tlbmQvYWNjZXNzL2NvbW1vbi9kZXRvYXN0LmMKaW5kZXggMzU0N2NkYmE1NmUuLjM5 YzgwMWEwYTUyIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvY29tbW9uL2RldG9h c3QuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvY29tbW9uL2RldG9hc3QuYwpAQCAtMjAs NiArMjAsOCBAQAogI2luY2x1ZGUgImNvbW1vbi9pbnQuaCIKICNpbmNsdWRlICJjb21tb24v cGdfbHpjb21wcmVzcy5oIgogI2luY2x1ZGUgInV0aWxzL2V4cGFuZGVkZGF0dW0uaCIKKyNp bmNsdWRlICJ1dGlscy9oc2VhcmNoLmgiCisjaW5jbHVkZSAidXRpbHMvbWVtdXRpbHMuaCIK ICNpbmNsdWRlICJ1dGlscy9yZWwuaCIKIAogc3RhdGljIHN0cnVjdCB2YXJsZW5hICp0b2Fz dF9mZXRjaF9kYXR1bShzdHJ1Y3QgdmFybGVuYSAqYXR0cik7CkBAIC0yOSw2ICszMSwyNSBA QCBzdGF0aWMgc3RydWN0IHZhcmxlbmEgKnRvYXN0X2ZldGNoX2RhdHVtX3NsaWNlKHN0cnVj dCB2YXJsZW5hICphdHRyLAogc3RhdGljIHN0cnVjdCB2YXJsZW5hICp0b2FzdF9kZWNvbXBy ZXNzX2RhdHVtKHN0cnVjdCB2YXJsZW5hICphdHRyKTsKIHN0YXRpYyBzdHJ1Y3QgdmFybGVu YSAqdG9hc3RfZGVjb21wcmVzc19kYXR1bV9zbGljZShzdHJ1Y3QgdmFybGVuYSAqYXR0ciwg aW50MzIgc2xpY2VsZW5ndGgpOwogCitib29sIGVuYWJsZV90b2FzdF9jYWNoZSA9IGZhbHNl OworCitIVEFCICp0b2FzdENhY2hlID0gTlVMTDsKK01lbW9yeUNvbnRleHQgVG9hc3RDYWNo ZUNvbnRleHQgPSBOVUxMOworCit0eXBlZGVmIHN0cnVjdCB0b2FzdF9jYWNoZV9rZXkgewor CU9pZCB0b2FzdHJlbGlkOworCU9pZCB2YWx1ZWlkOworfSB0b2FzdF9jYWNoZV9rZXk7CisK K3R5cGVkZWYgc3RydWN0IHRvYXN0X2NhY2hlX2VudHJ5IHsKKwl0b2FzdF9jYWNoZV9rZXkg a2V5OworCWludDMyCXNpemU7CisJdm9pZCAgICpkYXRhOworfSB0b2FzdF9jYWNoZV9lbnRy eTsKKworc3RhdGljIHRvYXN0X2NhY2hlX2VudHJ5ICp0b2FzdF9jYWNoZV9sb29rdXAoT2lk IHRvYXN0cmVsaWQsIE9pZCB2YWx1ZWlkKTsKK3N0YXRpYyB2b2lkIHRvYXN0X2NhY2hlX2Fk ZF9lbnRyeShPaWQgdG9hc3RyZWxpZCwgT2lkIHZhbHVlaWQsIHN0cnVjdCB2YXJsZW5hICph dHRyKTsKKwogLyogLS0tLS0tLS0tLQogICogZGV0b2FzdF9leHRlcm5hbF9hdHRyIC0KICAq CkBAIC0zNDYsNiArMzY3LDcgQEAgdG9hc3RfZmV0Y2hfZGF0dW0oc3RydWN0IHZhcmxlbmEg KmF0dHIpCiAJc3RydWN0IHZhcmxlbmEgKnJlc3VsdDsKIAlzdHJ1Y3QgdmFyYXR0X2V4dGVy bmFsIHRvYXN0X3BvaW50ZXI7CiAJaW50MzIJCWF0dHJzaXplOworCXRvYXN0X2NhY2hlX2Vu dHJ5ICplbnRyeTsKIAogCWlmICghVkFSQVRUX0lTX0VYVEVSTkFMX09ORElTSyhhdHRyKSkK IAkJZWxvZyhFUlJPUiwgInRvYXN0X2ZldGNoX2RhdHVtIHNob3VsZG4ndCBiZSBjYWxsZWQg Zm9yIG5vbi1vbmRpc2sgZGF0dW1zIik7CkBAIC0zNjYsNiArMzg4LDE2IEBAIHRvYXN0X2Zl dGNoX2RhdHVtKHN0cnVjdCB2YXJsZW5hICphdHRyKQogCQlyZXR1cm4gcmVzdWx0OwkJCS8q IFByb2JhYmx5IHNob3VsZG4ndCBoYXBwZW4sIGJ1dCBqdXN0IGluCiAJCQkJCQkJCSAqIGNh c2UuICovCiAKKwkvKiB0cnkgbG9va3VwIGluIHRoZSB0b2FzdCBjYWNoZSAqLworCWVudHJ5 ID0gdG9hc3RfY2FjaGVfbG9va3VwKHRvYXN0X3BvaW50ZXIudmFfdG9hc3RyZWxpZCwKKwkJ CQkJCQkgICB0b2FzdF9wb2ludGVyLnZhX3ZhbHVlaWQpOworCisJaWYgKGVudHJ5KQorCXsK KwkJbWVtY3B5KFZBUkRBVEEocmVzdWx0KSwgZW50cnktPmRhdGEsIGF0dHJzaXplKTsKKwkJ cmV0dXJuIHJlc3VsdDsKKwl9CisKIAkvKgogCSAqIE9wZW4gdGhlIHRvYXN0IHJlbGF0aW9u IGFuZCBpdHMgaW5kZXhlcwogCSAqLwpAQCAtMzc4LDYgKzQxMCwxMCBAQCB0b2FzdF9mZXRj aF9kYXR1bShzdHJ1Y3QgdmFybGVuYSAqYXR0cikKIAkvKiBDbG9zZSB0b2FzdCB0YWJsZSAq LwogCXRhYmxlX2Nsb3NlKHRvYXN0cmVsLCBBY2Nlc3NTaGFyZUxvY2spOwogCisJdG9hc3Rf Y2FjaGVfYWRkX2VudHJ5KHRvYXN0X3BvaW50ZXIudmFfdG9hc3RyZWxpZCwKKwkJCQkJCSAg dG9hc3RfcG9pbnRlci52YV92YWx1ZWlkLAorCQkJCQkJICByZXN1bHQpOworCiAJcmV0dXJu IHJlc3VsdDsKIH0KIApAQCAtNjQ0LDMgKzY4MCw5MyBAQCB0b2FzdF9kYXR1bV9zaXplKERh dHVtIHZhbHVlKQogCX0KIAlyZXR1cm4gcmVzdWx0OwogfQorCitzdGF0aWMgYm9vbAordG9h c3RfY2FjaGVfaW5pdCh2b2lkKQoreworCUhBU0hDVEwJCWN0bDsKKworCWlmICghZW5hYmxl X3RvYXN0X2NhY2hlKQorCQlyZXR1cm4gZmFsc2U7CisKKwkvKiBhbHJlYWR5IGluaXRpYWxp emVkICovCisJaWYgKHRvYXN0Q2FjaGUpCisJCXJldHVybiB0cnVlOworCisJLyogRklYTUUg c2hvdWxkIHJlYWxseSBiZSBwZXIgcXVlcnkgKi8KKwlUb2FzdENhY2hlQ29udGV4dCA9IEFs bG9jU2V0Q29udGV4dENyZWF0ZShUb3BNZW1vcnlDb250ZXh0LAorCQkJCQkJCQkJCQkgICJU T0FTVCBjYWNoZSBjb250ZXh0IiwKKwkJCQkJCQkJCQkJICBBTExPQ1NFVF9ERUZBVUxUX1NJ WkVTKTsKKworCS8qIE1ha2UgYSBuZXcgaGFzaCB0YWJsZSBmb3IgdGhlIGNhY2hlICovCisJ Y3RsLmtleXNpemUgPSBzaXplb2YodG9hc3RfY2FjaGVfa2V5KTsKKwljdGwuZW50cnlzaXpl ID0gc2l6ZW9mKHRvYXN0X2NhY2hlX2VudHJ5KTsKKwljdGwuaGN4dCA9IFRvYXN0Q2FjaGVD b250ZXh0OworCisJdG9hc3RDYWNoZSA9IGhhc2hfY3JlYXRlKCJUT0FTVCBjYWNoZSIsCisJ CQkJCQkJIDEyOCwgJmN0bCwKKwkJCQkJCQkgSEFTSF9FTEVNIHwgSEFTSF9DT05URVhUIHwg SEFTSF9CTE9CUyk7CisKKwlyZXR1cm4gdHJ1ZTsKK30KKworc3RhdGljIHRvYXN0X2NhY2hl X2VudHJ5ICoKK3RvYXN0X2NhY2hlX2xvb2t1cChPaWQgdG9hc3RyZWxpZCwgT2lkIHZhbHVl aWQpCit7CisJdG9hc3RfY2FjaGVfa2V5CQlrZXk7CisJdG9hc3RfY2FjaGVfZW50cnkgICpl bnRyeTsKKworCS8qIG1ha2Ugc3VyZSBjYWNoZSBpbml0aWFsaXplZCAqLworCWlmICghdG9h c3RfY2FjaGVfaW5pdCgpKQorCQlyZXR1cm4gTlVMTDsKKworCWtleS50b2FzdHJlbGlkID0g dG9hc3RyZWxpZDsKKwlrZXkudmFsdWVpZCA9IHZhbHVlaWQ7CisKKwllbnRyeSA9ICh0b2Fz dF9jYWNoZV9lbnRyeSAqKSBoYXNoX3NlYXJjaCh0b2FzdENhY2hlLCAma2V5LAorCQkJCQkJ CQkJCQkgIEhBU0hfRklORCwgTlVMTCk7CisKKwlyZXR1cm4gZW50cnk7Cit9CisKK3N0YXRp YyB2b2lkCit0b2FzdF9jYWNoZV9hZGRfZW50cnkoT2lkIHRvYXN0cmVsaWQsIE9pZCB2YWx1 ZWlkLCBzdHJ1Y3QgdmFybGVuYSAqYXR0cikKK3sKKwlib29sCQkJCWZvdW5kID0gZmFsc2U7 CisJdG9hc3RfY2FjaGVfa2V5CQlrZXk7CisJdG9hc3RfY2FjaGVfZW50cnkgICplbnRyeTsK KworCS8qIG1ha2Ugc3VyZSBjYWNoZSBpbml0aWFsaXplZCAqLworCWlmICghdG9hc3RfY2Fj aGVfaW5pdCgpKQorCQlyZXR1cm47CisKKwlrZXkudG9hc3RyZWxpZCA9IHRvYXN0cmVsaWQ7 CisJa2V5LnZhbHVlaWQgPSB2YWx1ZWlkOworCisJZW50cnkgPSAodG9hc3RfY2FjaGVfZW50 cnkgKikgaGFzaF9zZWFyY2godG9hc3RDYWNoZSwgJmtleSwKKwkJCQkJCQkJCQkJICBIQVNI X0VOVEVSLCAmZm91bmQpOworCisJQXNzZXJ0KCFmb3VuZCk7CisKKwllbnRyeS0+c2l6ZSA9 IFZBUlNJWkVfQU5ZX0VYSERSKGF0dHIpOworCWVudHJ5LT5kYXRhID0gTWVtb3J5Q29udGV4 dEFsbG9jKFRvYXN0Q2FjaGVDb250ZXh0LCBlbnRyeS0+c2l6ZSk7CisJbWVtY3B5KGVudHJ5 LT5kYXRhLCBWQVJEQVRBX0FOWShhdHRyKSwgZW50cnktPnNpemUpOworfQorCitzdGF0aWMg dm9pZAordG9hc3RfY2FjaGVfZGVzdHJveSh2b2lkKQoreworCWlmICghdG9hc3RDYWNoZSkK KwkJcmV0dXJuOworCisJTWVtb3J5Q29udGV4dERlbGV0ZShUb2FzdENhY2hlQ29udGV4dCk7 CisKKwl0b2FzdENhY2hlID0gTlVMTDsKKwlUb2FzdENhY2hlQ29udGV4dCA9IE5VTEw7Cit9 CisKK3ZvaWQKK0F0RU9YYWN0X1RvYXN0Q2FjaGUodm9pZCkKK3sKKwl0b2FzdF9jYWNoZV9k ZXN0cm95KCk7Cit9CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvdHJhbnNhbS94 YWN0LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvdHJhbnNhbS94YWN0LmMKaW5kZXggNzBhYjZl MjdhMTMuLjJjYWUzNTgyMDI2IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvdHJh bnNhbS94YWN0LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL3RyYW5zYW0veGFjdC5jCkBA IC0yMSw2ICsyMSw3IEBACiAjaW5jbHVkZSA8dW5pc3RkLmg+CiAKICNpbmNsdWRlICJhY2Nl c3MvY29tbWl0X3RzLmgiCisjaW5jbHVkZSAiYWNjZXNzL2RldG9hc3QuaCIKICNpbmNsdWRl ICJhY2Nlc3MvbXVsdGl4YWN0LmgiCiAjaW5jbHVkZSAiYWNjZXNzL3BhcmFsbGVsLmgiCiAj aW5jbHVkZSAiYWNjZXNzL3N1YnRyYW5zLmgiCkBAIC0yMzgxLDYgKzIzODIsNyBAQCBDb21t aXRUcmFuc2FjdGlvbih2b2lkKQogCUF0RU9YYWN0X1NuYXBzaG90KHRydWUsIGZhbHNlKTsK IAlBdEVPWGFjdF9BcHBseUxhdW5jaGVyKHRydWUpOwogCUF0RU9YYWN0X0xvZ2ljYWxSZXBX b3JrZXJzKHRydWUpOworCUF0RU9YYWN0X1RvYXN0Q2FjaGUoKTsKIAlwZ3N0YXRfcmVwb3J0 X3hhY3RfdGltZXN0YW1wKDApOwogCiAJUmVzb3VyY2VPd25lckRlbGV0ZShUb3BUcmFuc2Fj dGlvblJlc291cmNlT3duZXIpOwpAQCAtMjY3MSw2ICsyNjczLDcgQEAgUHJlcGFyZVRyYW5z YWN0aW9uKHZvaWQpCiAJLyogd2UgdHJlYXQgUFJFUEFSRSBhcyBST0xMQkFDSyBzbyBmYXIg YXMgd2FraW5nIHdvcmtlcnMgZ29lcyAqLwogCUF0RU9YYWN0X0FwcGx5TGF1bmNoZXIoZmFs c2UpOwogCUF0RU9YYWN0X0xvZ2ljYWxSZXBXb3JrZXJzKGZhbHNlKTsKKwlBdEVPWGFjdF9U b2FzdENhY2hlKCk7CiAJcGdzdGF0X3JlcG9ydF94YWN0X3RpbWVzdGFtcCgwKTsKIAogCUN1 cnJlbnRSZXNvdXJjZU93bmVyID0gTlVMTDsKQEAgLTI4ODgsNiArMjg5MSw3IEBAIEFib3J0 VHJhbnNhY3Rpb24odm9pZCkKIAkJQXRFT1hhY3RfUGdTdGF0KGZhbHNlLCBpc19wYXJhbGxl bF93b3JrZXIpOwogCQlBdEVPWGFjdF9BcHBseUxhdW5jaGVyKGZhbHNlKTsKIAkJQXRFT1hh Y3RfTG9naWNhbFJlcFdvcmtlcnMoZmFsc2UpOworCQlBdEVPWGFjdF9Ub2FzdENhY2hlKCk7 CiAJCXBnc3RhdF9yZXBvcnRfeGFjdF90aW1lc3RhbXAoMCk7CiAJfQogCmRpZmYgLS1naXQg YS9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1Y190YWJsZXMuYyBiL3NyYy9iYWNrZW5kL3V0 aWxzL21pc2MvZ3VjX3RhYmxlcy5jCmluZGV4IDkzZGVkMzFlZDkyLi5jZWIzZDNiOTUzYyAx MDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWNfdGFibGVzLmMKKysrIGIv c3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWNfdGFibGVzLmMKQEAgLTI3LDYgKzI3LDcgQEAK ICNlbmRpZgogCiAjaW5jbHVkZSAiYWNjZXNzL2NvbW1pdF90cy5oIgorI2luY2x1ZGUgImFj Y2Vzcy9kZXRvYXN0LmgiCiAjaW5jbHVkZSAiYWNjZXNzL2dpbi5oIgogI2luY2x1ZGUgImFj Y2Vzcy9zbHJ1LmgiCiAjaW5jbHVkZSAiYWNjZXNzL3RvYXN0X2NvbXByZXNzaW9uLmgiCkBA IC0xMDE1LDYgKzEwMTYsMTYgQEAgc3RydWN0IGNvbmZpZ19ib29sIENvbmZpZ3VyZU5hbWVz Qm9vbFtdID0KIAkJdHJ1ZSwKIAkJTlVMTCwgTlVMTCwgTlVMTAogCX0sCisJeworCQl7ImVu YWJsZV90b2FzdF9jYWNoZSIsIFBHQ19VU0VSU0VULCBRVUVSWV9UVU5JTkdfTUVUSE9ELAor CQkJZ2V0dGV4dF9ub29wKCJFbmFibGVzIGNhY2hpbmcgb2YgZGV0b2FzdGVkIHZhbHVlcy4i KSwKKwkJCU5VTEwsCisJCQlHVUNfRVhQTEFJTgorCQl9LAorCQkmZW5hYmxlX3RvYXN0X2Nh Y2hlLAorCQlmYWxzZSwKKwkJTlVMTCwgTlVMTCwgTlVMTAorCX0sCiAJewogCQl7ImdlcW8i LCBQR0NfVVNFUlNFVCwgUVVFUllfVFVOSU5HX0dFUU8sCiAJCQlnZXR0ZXh0X25vb3AoIkVu YWJsZXMgZ2VuZXRpYyBxdWVyeSBvcHRpbWl6YXRpb24uIiksCmRpZmYgLS1naXQgYS9zcmMv aW5jbHVkZS9hY2Nlc3MvZGV0b2FzdC5oIGIvc3JjL2luY2x1ZGUvYWNjZXNzL2RldG9hc3Qu aAppbmRleCAxMmQ4Y2RiMzU2YS4uMWE2NjJjODEzODggMTAwNjQ0Ci0tLSBhL3NyYy9pbmNs dWRlL2FjY2Vzcy9kZXRvYXN0LmgKKysrIGIvc3JjL2luY2x1ZGUvYWNjZXNzL2RldG9hc3Qu aApAQCAtNzksNCArNzksNyBAQCBleHRlcm4gU2l6ZSB0b2FzdF9yYXdfZGF0dW1fc2l6ZShE YXR1bSB2YWx1ZSk7CiAgKi8KIGV4dGVybiBTaXplIHRvYXN0X2RhdHVtX3NpemUoRGF0dW0g dmFsdWUpOwogCitleHRlcm4gUEdETExJTVBPUlQgYm9vbCBlbmFibGVfdG9hc3RfY2FjaGU7 CitleHRlcm4gdm9pZCBBdEVPWGFjdF9Ub2FzdENhY2hlKHZvaWQpOworCiAjZW5kaWYJCQkJ CQkJLyogREVUT0FTVF9IICovCg== --------------jgXE3gDwRNJy5LoLC9WTGVCz Content-Type: text/x-patch; charset=UTF-8; name="toast-cache-v2.patch" Content-Disposition: attachment; filename="toast-cache-v2.patch" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9jb21tb24vZGV0b2FzdC5jIGIvc3Jj L2JhY2tlbmQvYWNjZXNzL2NvbW1vbi9kZXRvYXN0LmMKaW5kZXggMzU0N2NkYmE1NmUuLjUw NDk0MTBlODFmIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvY29tbW9uL2RldG9h c3QuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvY29tbW9uL2RldG9hc3QuYwpAQCAtMjAs NiArMjAsOCBAQAogI2luY2x1ZGUgImNvbW1vbi9pbnQuaCIKICNpbmNsdWRlICJjb21tb24v cGdfbHpjb21wcmVzcy5oIgogI2luY2x1ZGUgInV0aWxzL2V4cGFuZGVkZGF0dW0uaCIKKyNp bmNsdWRlICJ1dGlscy9oc2VhcmNoLmgiCisjaW5jbHVkZSAidXRpbHMvbWVtdXRpbHMuaCIK ICNpbmNsdWRlICJ1dGlscy9yZWwuaCIKIAogc3RhdGljIHN0cnVjdCB2YXJsZW5hICp0b2Fz dF9mZXRjaF9kYXR1bShzdHJ1Y3QgdmFybGVuYSAqYXR0cik7CkBAIC0yOSw2ICszMSwzMCBA QCBzdGF0aWMgc3RydWN0IHZhcmxlbmEgKnRvYXN0X2ZldGNoX2RhdHVtX3NsaWNlKHN0cnVj dCB2YXJsZW5hICphdHRyLAogc3RhdGljIHN0cnVjdCB2YXJsZW5hICp0b2FzdF9kZWNvbXBy ZXNzX2RhdHVtKHN0cnVjdCB2YXJsZW5hICphdHRyKTsKIHN0YXRpYyBzdHJ1Y3QgdmFybGVu YSAqdG9hc3RfZGVjb21wcmVzc19kYXR1bV9zbGljZShzdHJ1Y3QgdmFybGVuYSAqYXR0ciwg aW50MzIgc2xpY2VsZW5ndGgpOwogCitib29sIGVuYWJsZV90b2FzdF9jYWNoZSA9IGZhbHNl OworCitIVEFCICp0b2FzdENhY2hlID0gTlVMTDsKK01lbW9yeUNvbnRleHQgVG9hc3RDYWNo ZUNvbnRleHQgPSBOVUxMOworCitzdGF0aWMgdWludDY0CXRvYXN0X2NhY2hlX2hpdHMgPSAw Oworc3RhdGljIHVpbnQ2NAl0b2FzdF9jYWNoZV9taXNzZXMgPSAwOworCit0eXBlZGVmIHN0 cnVjdCB0b2FzdF9jYWNoZV9rZXkgeworCU9pZCB0b2FzdHJlbGlkOworCU9pZCB2YWx1ZWlk OworfSB0b2FzdF9jYWNoZV9rZXk7CisKK3R5cGVkZWYgc3RydWN0IHRvYXN0X2NhY2hlX2Vu dHJ5IHsKKwl0b2FzdF9jYWNoZV9rZXkga2V5OworCWludDMyCXNpemU7CisJdm9pZCAgICpk YXRhOworfSB0b2FzdF9jYWNoZV9lbnRyeTsKKworc3RhdGljIHRvYXN0X2NhY2hlX2VudHJ5 ICp0b2FzdF9jYWNoZV9sb29rdXAoT2lkIHRvYXN0cmVsaWQsIE9pZCB2YWx1ZWlkKTsKK3N0 YXRpYyB2b2lkIHRvYXN0X2NhY2hlX2FkZF9lbnRyeShPaWQgdG9hc3RyZWxpZCwgT2lkIHZh bHVlaWQsIHN0cnVjdCB2YXJsZW5hICphdHRyKTsKK3N0YXRpYyBzdHJ1Y3QgdmFybGVuYSAq dG9hc3RfY2FjaGVfbG9va3VwX2RhdHVtKHRvYXN0X2NhY2hlX2tleSBrZXkpOworc3RhdGlj IHZvaWQgdG9hc3RfY2FjaGVfc3RvcmVfZGF0dW0odG9hc3RfY2FjaGVfa2V5IGtleSwgc3Ry dWN0IHZhcmxlbmEgKmF0dHIpOworCiAvKiAtLS0tLS0tLS0tCiAgKiBkZXRvYXN0X2V4dGVy bmFsX2F0dHIgLQogICoKQEAgLTExNyw2ICsxNDMsMjggQEAgZGV0b2FzdF9hdHRyKHN0cnVj dCB2YXJsZW5hICphdHRyKQogewogCWlmIChWQVJBVFRfSVNfRVhURVJOQUxfT05ESVNLKGF0 dHIpKQogCXsKKwkJc3RydWN0IHZhcmxlbmEgKnJlc3VsdDsKKwkJdG9hc3RfY2FjaGVfa2V5 CWtleTsKKworCQkvKiBjYWxjdWxhdGUgdGhlIGNhY2hlIGtleSAqLworCQl7CisJCQlzdHJ1 Y3QgdmFyYXR0X2V4dGVybmFsIHRvYXN0X3BvaW50ZXI7CisKKwkJCS8qIE11c3QgY29weSB0 byBhY2Nlc3MgYWxpZ25lZCBmaWVsZHMgKi8KKwkJCVZBUkFUVF9FWFRFUk5BTF9HRVRfUE9J TlRFUih0b2FzdF9wb2ludGVyLCBhdHRyKTsKKworCQkJLyogdHJ5IGxvb2t1cCBpbiB0aGUg dG9hc3QgY2FjaGUgKi8KKwkJCWtleS50b2FzdHJlbGlkID0gdG9hc3RfcG9pbnRlci52YV90 b2FzdHJlbGlkOworCQkJa2V5LnZhbHVlaWQgPSB0b2FzdF9wb2ludGVyLnZhX3ZhbHVlaWQ7 CisJCX0KKworCQkvKiBmaXJzdCB0cnkgdG8gbG9va3VwIGluIHRoZSB0b2FzdCBjYWNoZSAq LworCQlyZXN1bHQgPSB0b2FzdF9jYWNoZV9sb29rdXBfZGF0dW0oa2V5KTsKKworCQkvKiBj YWNoZSBoaXQsIHdlJ3JlIGRvbmUgKi8KKwkJaWYgKHJlc3VsdCkKKwkJCXJldHVybiByZXN1 bHQ7CisKIAkJLyoKIAkJICogVGhpcyBpcyBhbiBleHRlcm5hbGx5IHN0b3JlZCBkYXR1bSAt LS0gZmV0Y2ggaXQgYmFjayBmcm9tIHRoZXJlCiAJCSAqLwpAQCAtMTI5LDYgKzE3Nyw4IEBA IGRldG9hc3RfYXR0cihzdHJ1Y3QgdmFybGVuYSAqYXR0cikKIAkJCWF0dHIgPSB0b2FzdF9k ZWNvbXByZXNzX2RhdHVtKHRtcCk7CiAJCQlwZnJlZSh0bXApOwogCQl9CisKKwkJdG9hc3Rf Y2FjaGVfc3RvcmVfZGF0dW0oa2V5LCBhdHRyKTsKIAl9CiAJZWxzZSBpZiAoVkFSQVRUX0lT X0VYVEVSTkFMX0lORElSRUNUKGF0dHIpKQogCXsKQEAgLTY0NCwzICs2OTQsMTMwIEBAIHRv YXN0X2RhdHVtX3NpemUoRGF0dW0gdmFsdWUpCiAJfQogCXJldHVybiByZXN1bHQ7CiB9CisK K3N0YXRpYyBib29sCit0b2FzdF9jYWNoZV9pbml0KHZvaWQpCit7CisJSEFTSENUTAkJY3Rs OworCisJaWYgKCFlbmFibGVfdG9hc3RfY2FjaGUpCisJCXJldHVybiBmYWxzZTsKKworCS8q IGFscmVhZHkgaW5pdGlhbGl6ZWQgKi8KKwlpZiAodG9hc3RDYWNoZSkKKwkJcmV0dXJuIHRy dWU7CisKKwl0b2FzdF9jYWNoZV9oaXRzID0gMDsKKwl0b2FzdF9jYWNoZV9taXNzZXMgPSAw OworCisJLyogRklYTUUgc2hvdWxkIHJlYWxseSBiZSBwZXIgcXVlcnkgKi8KKwlUb2FzdENh Y2hlQ29udGV4dCA9IEFsbG9jU2V0Q29udGV4dENyZWF0ZShUb3BNZW1vcnlDb250ZXh0LAor CQkJCQkJCQkJCQkgICJUT0FTVCBjYWNoZSBjb250ZXh0IiwKKwkJCQkJCQkJCQkJICBBTExP Q1NFVF9ERUZBVUxUX1NJWkVTKTsKKworCS8qIE1ha2UgYSBuZXcgaGFzaCB0YWJsZSBmb3Ig dGhlIGNhY2hlICovCisJY3RsLmtleXNpemUgPSBzaXplb2YodG9hc3RfY2FjaGVfa2V5KTsK KwljdGwuZW50cnlzaXplID0gc2l6ZW9mKHRvYXN0X2NhY2hlX2VudHJ5KTsKKwljdGwuaGN4 dCA9IFRvYXN0Q2FjaGVDb250ZXh0OworCisJdG9hc3RDYWNoZSA9IGhhc2hfY3JlYXRlKCJU T0FTVCBjYWNoZSIsCisJCQkJCQkJIDEyOCwgJmN0bCwKKwkJCQkJCQkgSEFTSF9FTEVNIHwg SEFTSF9DT05URVhUIHwgSEFTSF9CTE9CUyk7CisKKwlyZXR1cm4gdHJ1ZTsKK30KKworc3Rh dGljIHRvYXN0X2NhY2hlX2VudHJ5ICoKK3RvYXN0X2NhY2hlX2xvb2t1cChPaWQgdG9hc3Ry ZWxpZCwgT2lkIHZhbHVlaWQpCit7CisJdG9hc3RfY2FjaGVfa2V5CQlrZXk7CisJdG9hc3Rf Y2FjaGVfZW50cnkgICplbnRyeTsKKworCS8qIG1ha2Ugc3VyZSBjYWNoZSBpbml0aWFsaXpl ZCAqLworCWlmICghdG9hc3RfY2FjaGVfaW5pdCgpKQorCQlyZXR1cm4gTlVMTDsKKworCWtl eS50b2FzdHJlbGlkID0gdG9hc3RyZWxpZDsKKwlrZXkudmFsdWVpZCA9IHZhbHVlaWQ7CisK KwllbnRyeSA9ICh0b2FzdF9jYWNoZV9lbnRyeSAqKSBoYXNoX3NlYXJjaCh0b2FzdENhY2hl LCAma2V5LAorCQkJCQkJCQkJCQkgIEhBU0hfRklORCwgTlVMTCk7CisKKwlpZiAoZW50cnkp CisJCXRvYXN0X2NhY2hlX2hpdHMrKzsKKwllbHNlCisJCXRvYXN0X2NhY2hlX21pc3Nlcysr OworCisJcmV0dXJuIGVudHJ5OworfQorCitzdGF0aWMgdm9pZAordG9hc3RfY2FjaGVfYWRk X2VudHJ5KE9pZCB0b2FzdHJlbGlkLCBPaWQgdmFsdWVpZCwgc3RydWN0IHZhcmxlbmEgKmF0 dHIpCit7CisJYm9vbAkJCQlmb3VuZCA9IGZhbHNlOworCXRvYXN0X2NhY2hlX2tleQkJa2V5 OworCXRvYXN0X2NhY2hlX2VudHJ5ICAqZW50cnk7CisKKwkvKiBtYWtlIHN1cmUgY2FjaGUg aW5pdGlhbGl6ZWQgKi8KKwlpZiAoIXRvYXN0X2NhY2hlX2luaXQoKSkKKwkJcmV0dXJuOwor CisJa2V5LnRvYXN0cmVsaWQgPSB0b2FzdHJlbGlkOworCWtleS52YWx1ZWlkID0gdmFsdWVp ZDsKKworCWVudHJ5ID0gKHRvYXN0X2NhY2hlX2VudHJ5ICopIGhhc2hfc2VhcmNoKHRvYXN0 Q2FjaGUsICZrZXksCisJCQkJCQkJCQkJCSAgSEFTSF9FTlRFUiwgJmZvdW5kKTsKKworCUFz c2VydCghZm91bmQpOworCisJZW50cnktPnNpemUgPSBWQVJTSVpFX0FOWV9FWEhEUihhdHRy KTsKKwllbnRyeS0+ZGF0YSA9IE1lbW9yeUNvbnRleHRBbGxvYyhUb2FzdENhY2hlQ29udGV4 dCwgZW50cnktPnNpemUpOworCW1lbWNweShlbnRyeS0+ZGF0YSwgVkFSREFUQV9BTlkoYXR0 ciksIGVudHJ5LT5zaXplKTsKK30KKworc3RhdGljIHZvaWQKK3RvYXN0X2NhY2hlX2Rlc3Ry b3kodm9pZCkKK3sKKwlpZiAoIXRvYXN0Q2FjaGUpCisJCXJldHVybjsKKworCWVsb2coTE9H LCAiQXRFT1hhY3RfVG9hc3RDYWNoZSBoaXRzICVsZCBtaXNzZXMgJWxkIHJhdGlvICUuMmYl JSIsCisJCSB0b2FzdF9jYWNoZV9oaXRzLCB0b2FzdF9jYWNoZV9taXNzZXMsCisJCSAodG9h c3RfY2FjaGVfaGl0cyAqIDEwMC4wKSAvIE1heCgxLCB0b2FzdF9jYWNoZV9oaXRzICsgdG9h c3RfY2FjaGVfbWlzc2VzKSk7CisKKwlNZW1vcnlDb250ZXh0RGVsZXRlKFRvYXN0Q2FjaGVD b250ZXh0KTsKKworCXRvYXN0Q2FjaGUgPSBOVUxMOworCVRvYXN0Q2FjaGVDb250ZXh0ID0g TlVMTDsKK30KKwordm9pZAorQXRFT1hhY3RfVG9hc3RDYWNoZSh2b2lkKQoreworCXRvYXN0 X2NhY2hlX2Rlc3Ryb3koKTsKK30KKworc3RhdGljIHN0cnVjdCB2YXJsZW5hICoKK3RvYXN0 X2NhY2hlX2xvb2t1cF9kYXR1bSh0b2FzdF9jYWNoZV9rZXkga2V5KQoreworCXRvYXN0X2Nh Y2hlX2VudHJ5ICplbnRyeTsKKwlzdHJ1Y3QgdmFybGVuYSAqcmVzdWx0ID0gTlVMTDsKKwor CWVudHJ5ID0gdG9hc3RfY2FjaGVfbG9va3VwKGtleS50b2FzdHJlbGlkLCBrZXkudmFsdWVp ZCk7CisKKwlpZiAoIWVudHJ5KQorCQlyZXR1cm4gTlVMTDsKKworCXJlc3VsdCA9IChzdHJ1 Y3QgdmFybGVuYSAqKSBwYWxsb2MoZW50cnktPnNpemUgKyBWQVJIRFJTWik7CisJU0VUX1ZB UlNJWkUocmVzdWx0LCBlbnRyeS0+c2l6ZSArIFZBUkhEUlNaKTsKKworCW1lbWNweShWQVJE QVRBKHJlc3VsdCksIGVudHJ5LT5kYXRhLCBlbnRyeS0+c2l6ZSk7CisKKwlyZXR1cm4gcmVz dWx0OworfQorCitzdGF0aWMgdm9pZAordG9hc3RfY2FjaGVfc3RvcmVfZGF0dW0odG9hc3Rf Y2FjaGVfa2V5IGtleSwgc3RydWN0IHZhcmxlbmEgKmF0dHIpCit7CisJdG9hc3RfY2FjaGVf YWRkX2VudHJ5KGtleS50b2FzdHJlbGlkLCBrZXkudmFsdWVpZCwgYXR0cik7Cit9CmRpZmYg LS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvdHJhbnNhbS94YWN0LmMgYi9zcmMvYmFja2Vu ZC9hY2Nlc3MvdHJhbnNhbS94YWN0LmMKaW5kZXggNzBhYjZlMjdhMTMuLjJjYWUzNTgyMDI2 IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvdHJhbnNhbS94YWN0LmMKKysrIGIv c3JjL2JhY2tlbmQvYWNjZXNzL3RyYW5zYW0veGFjdC5jCkBAIC0yMSw2ICsyMSw3IEBACiAj aW5jbHVkZSA8dW5pc3RkLmg+CiAKICNpbmNsdWRlICJhY2Nlc3MvY29tbWl0X3RzLmgiCisj aW5jbHVkZSAiYWNjZXNzL2RldG9hc3QuaCIKICNpbmNsdWRlICJhY2Nlc3MvbXVsdGl4YWN0 LmgiCiAjaW5jbHVkZSAiYWNjZXNzL3BhcmFsbGVsLmgiCiAjaW5jbHVkZSAiYWNjZXNzL3N1 YnRyYW5zLmgiCkBAIC0yMzgxLDYgKzIzODIsNyBAQCBDb21taXRUcmFuc2FjdGlvbih2b2lk KQogCUF0RU9YYWN0X1NuYXBzaG90KHRydWUsIGZhbHNlKTsKIAlBdEVPWGFjdF9BcHBseUxh dW5jaGVyKHRydWUpOwogCUF0RU9YYWN0X0xvZ2ljYWxSZXBXb3JrZXJzKHRydWUpOworCUF0 RU9YYWN0X1RvYXN0Q2FjaGUoKTsKIAlwZ3N0YXRfcmVwb3J0X3hhY3RfdGltZXN0YW1wKDAp OwogCiAJUmVzb3VyY2VPd25lckRlbGV0ZShUb3BUcmFuc2FjdGlvblJlc291cmNlT3duZXIp OwpAQCAtMjY3MSw2ICsyNjczLDcgQEAgUHJlcGFyZVRyYW5zYWN0aW9uKHZvaWQpCiAJLyog d2UgdHJlYXQgUFJFUEFSRSBhcyBST0xMQkFDSyBzbyBmYXIgYXMgd2FraW5nIHdvcmtlcnMg Z29lcyAqLwogCUF0RU9YYWN0X0FwcGx5TGF1bmNoZXIoZmFsc2UpOwogCUF0RU9YYWN0X0xv Z2ljYWxSZXBXb3JrZXJzKGZhbHNlKTsKKwlBdEVPWGFjdF9Ub2FzdENhY2hlKCk7CiAJcGdz dGF0X3JlcG9ydF94YWN0X3RpbWVzdGFtcCgwKTsKIAogCUN1cnJlbnRSZXNvdXJjZU93bmVy ID0gTlVMTDsKQEAgLTI4ODgsNiArMjg5MSw3IEBAIEFib3J0VHJhbnNhY3Rpb24odm9pZCkK IAkJQXRFT1hhY3RfUGdTdGF0KGZhbHNlLCBpc19wYXJhbGxlbF93b3JrZXIpOwogCQlBdEVP WGFjdF9BcHBseUxhdW5jaGVyKGZhbHNlKTsKIAkJQXRFT1hhY3RfTG9naWNhbFJlcFdvcmtl cnMoZmFsc2UpOworCQlBdEVPWGFjdF9Ub2FzdENhY2hlKCk7CiAJCXBnc3RhdF9yZXBvcnRf eGFjdF90aW1lc3RhbXAoMCk7CiAJfQogCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGls cy9taXNjL2d1Y190YWJsZXMuYyBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjX3RhYmxl cy5jCmluZGV4IDkzZGVkMzFlZDkyLi5jZWIzZDNiOTUzYyAxMDA2NDQKLS0tIGEvc3JjL2Jh Y2tlbmQvdXRpbHMvbWlzYy9ndWNfdGFibGVzLmMKKysrIGIvc3JjL2JhY2tlbmQvdXRpbHMv bWlzYy9ndWNfdGFibGVzLmMKQEAgLTI3LDYgKzI3LDcgQEAKICNlbmRpZgogCiAjaW5jbHVk ZSAiYWNjZXNzL2NvbW1pdF90cy5oIgorI2luY2x1ZGUgImFjY2Vzcy9kZXRvYXN0LmgiCiAj aW5jbHVkZSAiYWNjZXNzL2dpbi5oIgogI2luY2x1ZGUgImFjY2Vzcy9zbHJ1LmgiCiAjaW5j bHVkZSAiYWNjZXNzL3RvYXN0X2NvbXByZXNzaW9uLmgiCkBAIC0xMDE1LDYgKzEwMTYsMTYg QEAgc3RydWN0IGNvbmZpZ19ib29sIENvbmZpZ3VyZU5hbWVzQm9vbFtdID0KIAkJdHJ1ZSwK IAkJTlVMTCwgTlVMTCwgTlVMTAogCX0sCisJeworCQl7ImVuYWJsZV90b2FzdF9jYWNoZSIs IFBHQ19VU0VSU0VULCBRVUVSWV9UVU5JTkdfTUVUSE9ELAorCQkJZ2V0dGV4dF9ub29wKCJF bmFibGVzIGNhY2hpbmcgb2YgZGV0b2FzdGVkIHZhbHVlcy4iKSwKKwkJCU5VTEwsCisJCQlH VUNfRVhQTEFJTgorCQl9LAorCQkmZW5hYmxlX3RvYXN0X2NhY2hlLAorCQlmYWxzZSwKKwkJ TlVMTCwgTlVMTCwgTlVMTAorCX0sCiAJewogCQl7ImdlcW8iLCBQR0NfVVNFUlNFVCwgUVVF UllfVFVOSU5HX0dFUU8sCiAJCQlnZXR0ZXh0X25vb3AoIkVuYWJsZXMgZ2VuZXRpYyBxdWVy eSBvcHRpbWl6YXRpb24uIiksCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9hY2Nlc3MvZGV0 b2FzdC5oIGIvc3JjL2luY2x1ZGUvYWNjZXNzL2RldG9hc3QuaAppbmRleCAxMmQ4Y2RiMzU2 YS4uMWE2NjJjODEzODggMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL2FjY2Vzcy9kZXRvYXN0 LmgKKysrIGIvc3JjL2luY2x1ZGUvYWNjZXNzL2RldG9hc3QuaApAQCAtNzksNCArNzksNyBA QCBleHRlcm4gU2l6ZSB0b2FzdF9yYXdfZGF0dW1fc2l6ZShEYXR1bSB2YWx1ZSk7CiAgKi8K IGV4dGVybiBTaXplIHRvYXN0X2RhdHVtX3NpemUoRGF0dW0gdmFsdWUpOwogCitleHRlcm4g UEdETExJTVBPUlQgYm9vbCBlbmFibGVfdG9hc3RfY2FjaGU7CitleHRlcm4gdm9pZCBBdEVP WGFjdF9Ub2FzdENhY2hlKHZvaWQpOworCiAjZW5kaWYJCQkJCQkJLyogREVUT0FTVF9IICov Cg== --------------jgXE3gDwRNJy5LoLC9WTGVCz--