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 1s53PY-002s7Z-HI for pgsql-hackers@arkaria.postgresql.org; Thu, 09 May 2024 13:02:12 +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 1s53PW-006qqU-1A for pgsql-hackers@arkaria.postgresql.org; Thu, 09 May 2024 13:02:10 +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 1s53PV-006qnt-DE for pgsql-hackers@lists.postgresql.org; Thu, 09 May 2024 13:02:10 +0000 Received: from mail-ed1-x529.google.com ([2a00:1450:4864:20::529]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.94.2) (envelope-from ) id 1s53PQ-000Axl-0T for pgsql-hackers@postgresql.org; Thu, 09 May 2024 13:02:08 +0000 Received: by mail-ed1-x529.google.com with SMTP id 4fb4d7f45d1cf-572c65cea55so1548124a12.0 for ; Thu, 09 May 2024 06:02:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1715259721; x=1715864521; darn=postgresql.org; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=AMZlEpYWBmSQAlFR+q3CtZhpunEjV2QuzAOisY1CsOI=; b=dBZHwuHyZbEvOy9EDCs/fw9bH0NnLQv9IvwQCwGR1lK1u67Pjw3T1qyC8zU44BCHsH KS0i6V+SIz1hQiMwBarTwHI6oJmVTaLMkdveiWCTeavzmWwYIDTCEHDgxUoksJ6lfnYE qpA/9yKa8XCw7CIl6lGBCTOjO+FX9qrBumQh2tuLGE2v++lBBpLKT4V1prob/A0s4xkn VirA6UnOcKiqDk4c3PM/tUFUlOExcU0xq/5CWoHnUYZL3xHYW/+lCYirwSkMbR3Q7lkJ QmYuw0uvaIkVgrtS98oFQhliWh2gmaAoC3/zNMDrPlb8yGQDDSucUGvUNRoBoX2nV2P2 k6uQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1715259721; x=1715864521; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=AMZlEpYWBmSQAlFR+q3CtZhpunEjV2QuzAOisY1CsOI=; b=sA9hRPiaBMWCcVQkZOcZDeuBMhmKYj55BkqYLQ71X6V2nEJFRnDtwqEE9YZ16ea+2K w7pRz1IVzq380Z1QQFSMzHVzAhB4+7RZHj6Ec0HBAF4Ou42JpqimgYlSm1sejjZR/iRC vuczpZZBRGPPsslH+ZV1eeMxwFDTnZGTJbPgfPpNM/+qfT/DE7vPTXWyKFLPbpin5bOA CtIIJdbkFWAjNWZyuBQRj9A7BnmMgNtItvnrhKlF40sIZ2yoRsXHRMGSrX4ol31pATz6 t2lt7CgB1/j8+XtA3/dN0tFjSKlqo7Gkmv+lXZO7Lf+urMrYPzePsLtJC1UfG5J6jXIf GCUg== X-Forwarded-Encrypted: i=1; AJvYcCWTk5pecee25XMS9M42aD4WLqS1IWxjAKz2lgVl/KzpN9PYNVZdTd9np8nihjl0tZ9m71JKs51t045V2gkuU0XzJFl8j2+MF6+9ZCK+ X-Gm-Message-State: AOJu0YxUHPSyLzOz777pFUDxQzo09JLZ5+NP5Sj7ujTjmS6PLWIuKhE8 5g4KqoyVMNNP/OBqFWqCHf76W/yZjUiyruvE0BQ8yn30SVMiCsG1StWu8mWDAC4O3KRIsTdvZpV j2idE3qBO5/GmTU5+PH7WIkFEP0Oe+ZqK X-Google-Smtp-Source: AGHT+IEPiX0N6RAIB+2OPsxhBOMEE8mKrGQnfVTHcK+rqp5Fzpr6ZGBI4duMGYokLc+Q8TgJqDBj8K5DHbnQ69ezW6k= X-Received: by 2002:a05:6402:13d3:b0:572:b83e:e062 with SMTP id 4fb4d7f45d1cf-57332686076mr2471933a12.3.1715259721156; Thu, 09 May 2024 06:02:01 -0700 (PDT) MIME-Version: 1.0 References: In-Reply-To: From: Michail Nikolaev Date: Thu, 9 May 2024 15:00:00 +0200 Message-ID: Subject: Re: Revisiting {CREATE INDEX, REINDEX} CONCURRENTLY improvements To: Matthias van de Meent Cc: Melanie Plageman , PostgreSQL Hackers , Andrey Borodin Content-Type: multipart/mixed; boundary="00000000000060f4ca061805069d" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --00000000000060f4ca061805069d Content-Type: multipart/alternative; boundary="00000000000060f4c9061805069b" --00000000000060f4c9061805069b Content-Type: text/plain; charset="UTF-8" Hello, Matthias and others! Realized new horizon was applied only during validation phase (once index is marked as ready). Now it applied if index is not marked as valid yet. Updated version in attach. -------------------------------------------------- > I think the best way for this to work would be an index method that > exclusively stores TIDs, and of which we can quickly determine new > tuples, too. I was thinking about something like GIN's format, but > using (generation number, tid) instead of ([colno, colvalue], tid) as > key data for the internal trees, and would be unlogged (because the > data wouldn't have to survive a crash). Then we could do something > like this for the second table scan phase: Regarding that approach to dealing with validation phase and resetting of snapshot: I was thinking about it and realized: once we go for an additional index - we don't need the second heap scan at all! We may do it this way: * create target index, not marked as indisready yet * create a temporary unlogged index with the same parameters to store tids (optionally with the indexes columns data, see below), marked as indisready (but not indisvalid) * commit them both in a single transaction * wait for other transaction to know about them and honor in HOT constraints and new inserts (for temporary index) * now our temporary index is filled by the tuples inserted to the table * start building out target index, resetting snapshot every so often (if it is "safe" index) * finish target index building phase * mark target index as indisready * now, start validation of the index: * take the reference snapshot * take a visibility snapshot of the target index, sort it (as it done currently) * take a visibility snapshot of our temporary index, sort it * start merging loop using two synchronized cursors over both visibility snapshots * if we encountered tid which is not present in target visibility snapshot * insert it to target index * if a temporary index contains the column's data - we may even avoid the tuple fetch * if temporary index is tid-only - we fetch tuple from the heap, but as plus we are also skipping dead tuples from insertion to the new index (I think it is better option) * commit everything, release reference snapshot * wait for transactions older than reference snapshot (as it done currently) * mark target index as indisvalid, drop temporary index * done So, pros: * just a single heap scan * snapshot is reset periodically Cons: * we need to maintain the additional index during the main building phase * one more tuplesort If the temporary index is unlogged, cheap to maintain (just append-only mechanics) this feels like a perfect tradeoff for me. This approach will work perfectly with low amount of tuple inserts during the building phase. And looks like even in the worst case it still better than the current approach. What do you think? Have I missed something? Thanks, Michail. --00000000000060f4c9061805069b Content-Type: text/html; charset="UTF-8" Content-Transfer-Encoding: quoted-printable
Hello, Matthias and others!

Realized new horizon wa= s applied only during validation phase (once index is marked as ready).
= Now it applied if index is not marked as valid yet.

Updated version = in attach.

--------------------------------------------------
> I think the best way for this to work would be an index m= ethod that
> exclusively stores TIDs, and of which we can quickly det= ermine new
> tuples, too. I was thinking about something like GIN'= ;s format, but
> using (generation number, tid) instead of ([colno, c= olvalue], tid) as
> key data for the internal trees, and would be unl= ogged (because the
> data wouldn't have to survive a crash). Then= we could do something
> like this for the second table scan phase:
Regarding that approach to dealing with validation phase and resettin= g of snapshot:

I was thinking about it and realized: once we go for = an additional index - we don't need the second heap scan at all!
We may do it this way:

* create target index, not marked as indisre= ady yet
* create a temporary unlogged index with the same parameters to = store tids (optionally with the indexes columns data, see below), marked as= indisready (but not indisvalid)
* commit them both in a single transact= ion
* wait for other transaction to know about them and honor in HOT con= straints and new inserts (for temporary index)
* now our temporary index= is filled by the tuples inserted to the table
* start building out targ= et index, resetting snapshot every so often (if it is "safe" inde= x)
* finish target index building phase
* mark target index as indisr= eady
* now, start validation of the index:
=C2=A0 =C2=A0 * take the r= eference snapshot =C2=A0 =C2=A0
=C2=A0 =C2=A0 * take a visibility snapsh= ot of the target index, sort it (as it done currently)
=C2=A0 =C2=A0 * t= ake a visibility snapshot of our temporary index, sort it
=C2=A0 =C2=A0 = * start merging loop using two synchronized cursors over both visibility sn= apshots
=C2=A0 =C2=A0 =C2=A0 =C2=A0 * if we encountered tid which is not= present in target visibility snapshot
=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2= =A0 =C2=A0 * insert it to target index
=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2= =A0 =C2=A0 =C2=A0 =C2=A0 * if a temporary index contains the column's d= ata - we may even avoid the tuple fetch
=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2= =A0 =C2=A0 =C2=A0 =C2=A0 * if temporary index is tid-only - we fetch tuple = from the heap, but as plus we are also skipping dead tuples from insertion = to the new index (I think it is better option)
=C2=A0 =C2=A0 * commit ev= erything, release reference snapshot =C2=A0
* wait for transactions old= er than reference snapshot (as it done currently)
* mark target index as= indisvalid, drop temporary index
* done


So, pros:
* just = a single heap scan
* snapshot is reset periodically

Cons:
* we= need to maintain the additional index during the main building phase
* = one more tuplesort

If the temporary index is unlogged, cheap to main= tain (just append-only mechanics) this feels like a perfect tradeoff for me= .

This approach will work perfectly with low amount of tuple inserts= during the building phase. And looks like even in the worst case it still = better than the current approach.

What do you think? Have I missed s= omething?

Thanks,
Michail.
--00000000000060f4c9061805069b-- --00000000000060f4ca061805069d Content-Type: text/x-patch; charset="US-ASCII"; name="v4-0001-WIP-fix-d9d076222f5b-VACUUM-ignore-indexing-opera.patch" Content-Disposition: attachment; filename="v4-0001-WIP-fix-d9d076222f5b-VACUUM-ignore-indexing-opera.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lvz6r3ay0 RnJvbSA0ODc4Y2MyMmM5MTc2ZTViZjJiN2QzZDlkOGM5NWNjNjZjOGFjMDA3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBua2V5IDxtaWNoYWlsLm5pa29sYWV2QGdtYWlsLmNvbT4KRGF0 ZTogV2VkLCA4IE1heSAyMDI0IDIyOjMxOjMzICswMjAwClN1YmplY3Q6IFtQQVRDSCB2NF0gV0lQ OiBmaXggZDlkMDc2MjIyZjViICJWQUNVVU06IGlnbm9yZSBpbmRleGluZyBvcGVyYXRpb25zIAog d2l0aCBDT05DVVJSRU5UTFkiIHdoaWNoIHdhcyByZXZlcnRlZCBieSBlMjhiYjg4NTE5NjkuCgpJ c3N1ZSB3YXMgY2F1c2VkIGJ5IGFic2VudCBvZiBhbnkgc25hcHNob3QgYWN0dWFsbHkgcHJvdGVj dHMgdGhlIGRhdGEgaW4gcmVsYXRpb24gaW4gdGhlIHJlcXVpcmVkIHRvIGJ1aWxkIGluZGV4IGNv cnJlY3RseS4KCkludHJvZHVjZSBuZXcgdHlwZSBvZiB2aXNpYmlsaXR5IGhvcml6b24gdG8gYmUg dXNlZCBmb3IgcmVsYXRpb24gd2l0aCBjb25jdXJyZW50bHkgYnVpbGQgaW5kZXhlcyAoaW4gdGhl IGNhc2Ugb2YgInNhZmUiIGluZGV4KS4KCk5vdyBgR2xvYmFsVmlzSG9yaXpvbktpbmRGb3JSZWxg IG1heSBkeW5hbWljYWxseSBkZWNpZGUgd2hpY2ggaG9yaXpvbiB0byB1c2VkIGJhc2Ugb2YgdGhl IGRhdGEgYWJvdXQgc2FmZSBpbmRleGVzIGJlaW5nIGJ1aWx0IGNvbmN1cnJlbnRseS4KClRvIHJl ZHVjZSBwZXJmb3JtYW5jZSBpbXBhY3QgY291bnRlciBvZiBjb25jdXJyZW50bHkgYnVpbHQgaW5k ZXhlcyB1cGRhdGVkIGluIHNoYXJlZCBtZW1vcnkuCi0tLQogc3JjL2JhY2tlbmQvY2F0YWxvZy9p bmRleC5jICAgICAgICAgICAgICB8ICAzNiArKysrKysKIHNyYy9iYWNrZW5kL2NvbW1hbmRzL2lu ZGV4Y21kcy5jICAgICAgICAgfCAgMjAgKysrCiBzcmMvYmFja2VuZC9zdG9yYWdlL2lwYy9pcGNp LmMgICAgICAgICAgIHwgICAyICsKIHNyYy9iYWNrZW5kL3N0b3JhZ2UvaXBjL3Byb2NhcnJheS5j ICAgICAgfCAgODUgKysrKysrKysrKysrLQogc3JjL2JhY2tlbmQvdXRpbHMvY2FjaGUvcmVsY2Fj aGUuYyAgICAgICB8ICAxMSArKwogc3JjL2Jpbi9wZ19hbWNoZWNrL3QvMDA2X2NvbmN1cnJlbnRs eS5wbCB8IDE1NSArKysrKysrKysrKysrKysrKysrKysrKwogc3JjL2luY2x1ZGUvY2F0YWxvZy9p bmRleC5oICAgICAgICAgICAgICB8ICAgNSArCiBzcmMvaW5jbHVkZS91dGlscy9yZWwuaCAgICAg ICAgICAgICAgICAgIHwgICAxICsKIDggZmlsZXMgY2hhbmdlZCwgMzA5IGluc2VydGlvbnMoKyks IDYgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3JjL2Jpbi9wZ19hbWNoZWNrL3Qv MDA2X2NvbmN1cnJlbnRseS5wbAoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NhdGFsb2cvaW5k ZXguYyBiL3NyYy9iYWNrZW5kL2NhdGFsb2cvaW5kZXguYwppbmRleCA1YTg1NjhjNTVjLi4zY2Fh MmJhYjEyIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jYXRhbG9nL2luZGV4LmMKKysrIGIvc3Jj L2JhY2tlbmQvY2F0YWxvZy9pbmRleC5jCkBAIC05Nyw2ICs5NywxMSBAQCB0eXBlZGVmIHN0cnVj dAogCU9pZAkJCXBlbmRpbmdSZWluZGV4ZWRJbmRleGVzW0ZMRVhJQkxFX0FSUkFZX01FTUJFUl07 CiB9IFNlcmlhbGl6ZWRSZWluZGV4U3RhdGU7CiAKK3R5cGVkZWYgc3RydWN0IHsKKwlwZ19hdG9t aWNfdWludDMyIG51bVNhZmVDb25jdXJyZW50bHlCdWlsdEluZGV4ZXM7Cit9IFNhZmVJQ1NoYXJl ZFN0YXRlOworc3RhdGljIFNhZmVJQ1NoYXJlZFN0YXRlICpTYWZlSUNTdGF0ZVNobWVtOworCiAv KiBub24tZXhwb3J0IGZ1bmN0aW9uIHByb3RvdHlwZXMgKi8KIHN0YXRpYyBib29sIHJlbGF0aW9u SGFzUHJpbWFyeUtleShSZWxhdGlvbiByZWwpOwogc3RhdGljIFR1cGxlRGVzYyBDb25zdHJ1Y3RU dXBsZURlc2NyaXB0b3IoUmVsYXRpb24gaGVhcFJlbGF0aW9uLApAQCAtMTc2LDYgKzE4MSwzNyBA QCByZWxhdGlvbkhhc1ByaW1hcnlLZXkoUmVsYXRpb24gcmVsKQogCXJldHVybiByZXN1bHQ7CiB9 CiAKKwordm9pZCBTYWZlSUNTdGF0ZVNobWVtSW5pdCh2b2lkKQoreworCWJvb2wJCWZvdW5kOwor CisJU2FmZUlDU3RhdGVTaG1lbSA9IChTYWZlSUNTaGFyZWRTdGF0ZSAqKQorCQkJU2htZW1Jbml0 U3RydWN0KCJTYWZlIENvbmN1cnJlbnRseSBCdWlsZCBJbmRleGVzIiwKKwkJCQkJCQlzaXplb2Yo U2FmZUlDU2hhcmVkU3RhdGUpLAorCQkJCQkJCSZmb3VuZCk7CisKKwlpZiAoIUlzVW5kZXJQb3N0 bWFzdGVyKQorCXsKKwkJQXNzZXJ0KCFmb3VuZCk7CisJCXBnX2F0b21pY19pbml0X3UzMigmU2Fm ZUlDU3RhdGVTaG1lbS0+bnVtU2FmZUNvbmN1cnJlbnRseUJ1aWx0SW5kZXhlcywgMCk7CisJfSBl bHNlCisJCUFzc2VydChmb3VuZCk7Cit9CisKK3ZvaWQgVXBkYXRlTnVtU2FmZUNvbmN1cnJlbnRs eUJ1aWx0SW5kZXhlcyhib29sIGluY3JlbWVudCkKK3sKKwlpZiAoaW5jcmVtZW50KQorCQlwZ19h dG9taWNfZmV0Y2hfYWRkX3UzMigmU2FmZUlDU3RhdGVTaG1lbS0+bnVtU2FmZUNvbmN1cnJlbnRs eUJ1aWx0SW5kZXhlcywgMSk7CisJZWxzZQorCQlwZ19hdG9taWNfZmV0Y2hfc3ViX3UzMigmU2Fm ZUlDU3RhdGVTaG1lbS0+bnVtU2FmZUNvbmN1cnJlbnRseUJ1aWx0SW5kZXhlcywgMSk7Cit9CisK K2Jvb2wgSXNBbnlTYWZlSW5kZXhCdWlsZHNDb25jdXJyZW50bHkoKQoreworCXJldHVybiBwZ19h dG9taWNfcmVhZF91MzIoJlNhZmVJQ1N0YXRlU2htZW0tPm51bVNhZmVDb25jdXJyZW50bHlCdWls dEluZGV4ZXMpID4gMDsKK30KKwogLyoKICAqIGluZGV4X2NoZWNrX3ByaW1hcnlfa2V5CiAgKgkJ QXBwbHkgc3BlY2lhbCBjaGVja3MgbmVlZGVkIGJlZm9yZSBjcmVhdGluZyBhIFBSSU1BUlkgS0VZ IGluZGV4CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy9pbmRleGNtZHMuYyBiL3Ny Yy9iYWNrZW5kL2NvbW1hbmRzL2luZGV4Y21kcy5jCmluZGV4IGQ5MDE2ZWY0ODcuLjY2MzQ1MGJh MjAgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2luZGV4Y21kcy5jCisrKyBiL3Ny Yy9iYWNrZW5kL2NvbW1hbmRzL2luZGV4Y21kcy5jCkBAIC0xNjM2LDYgKzE2MzYsOCBAQCBEZWZp bmVJbmRleChPaWQgdGFibGVJZCwKIAkgKiBob2xkIGxvY2sgb24gdGhlIHBhcmVudCB0YWJsZS4g IFRoaXMgbWlnaHQgbmVlZCB0byBjaGFuZ2UgbGF0ZXIuCiAJICovCiAJTG9ja1JlbGF0aW9uSWRG b3JTZXNzaW9uKCZoZWFwcmVsaWQsIFNoYXJlVXBkYXRlRXhjbHVzaXZlTG9jayk7CisJaWYgKHNh ZmVfaW5kZXggJiYgY29uY3VycmVudCkKKwkJVXBkYXRlTnVtU2FmZUNvbmN1cnJlbnRseUJ1aWx0 SW5kZXhlcyh0cnVlKTsKIAogCVBvcEFjdGl2ZVNuYXBzaG90KCk7CiAJQ29tbWl0VHJhbnNhY3Rp b25Db21tYW5kKCk7CkBAIC0xODA0LDcgKzE4MDYsMTUgQEAgRGVmaW5lSW5kZXgoT2lkIHRhYmxl SWQsCiAJICogdG8gcmVwbGFuOyBzbyByZWxjYWNoZSBmbHVzaCBvbiB0aGUgaW5kZXggaXRzZWxm IHdhcyBzdWZmaWNpZW50LikKIAkgKi8KIAlDYWNoZUludmFsaWRhdGVSZWxjYWNoZUJ5UmVsaWQo aGVhcHJlbGlkLnJlbElkKTsKKwkvKiBDb21taXQgaW5kZXggYXMgdmFsaWQgYmVmb3JlIHJlZHVj aW5nIGNvdW50ZXIgb2Ygc2FmZSBjb25jdXJyZW50bHkgYnVpbGQgaW5kZXhlcyAqLworCUNvbW1p dFRyYW5zYWN0aW9uQ29tbWFuZCgpOwogCisJQXNzZXJ0KGNvbmN1cnJlbnQpOworCWlmIChzYWZl X2luZGV4KQorCQlVcGRhdGVOdW1TYWZlQ29uY3VycmVudGx5QnVpbHRJbmRleGVzKGZhbHNlKTsK KworCS8qIFN0YXJ0IGEgbmV3IHRyYW5zYWN0aW9uIHRvIGZpbmlzaCBwcm9jZXNzIHByb3Blcmx5 ICovCisJU3RhcnRUcmFuc2FjdGlvbkNvbW1hbmQoKTsKIAkvKgogCSAqIExhc3QgdGhpbmcgdG8g ZG8gaXMgcmVsZWFzZSB0aGUgc2Vzc2lvbi1sZXZlbCBsb2NrIG9uIHRoZSBwYXJlbnQgdGFibGUu CiAJICovCkBAIC0zOTAyLDYgKzM5MTIsOCBAQCBSZWluZGV4UmVsYXRpb25Db25jdXJyZW50bHko Y29uc3QgUmVpbmRleFN0bXQgKnN0bXQsIE9pZCByZWxhdGlvbk9pZCwgY29uc3QgUmVpbgogCQkJ CQkgaW5kZXhSZWwtPnJkX2luZHByZWQgPT0gTklMKTsKIAkJaWR4LT50YWJsZUlkID0gUmVsYXRp b25HZXRSZWxpZChoZWFwUmVsKTsKIAkJaWR4LT5hbUlkID0gaW5kZXhSZWwtPnJkX3JlbC0+cmVs YW07CisJCWlmIChpZHgtPnNhZmUpCisJCQlVcGRhdGVOdW1TYWZlQ29uY3VycmVudGx5QnVpbHRJ bmRleGVzKHRydWUpOwogCiAJCS8qIFRoaXMgZnVuY3Rpb24gc2hvdWxkbid0IGJlIGNhbGxlZCBm b3IgdGVtcG9yYXJ5IHJlbGF0aW9ucy4gKi8KIAkJaWYgKGluZGV4UmVsLT5yZF9yZWwtPnJlbHBl cnNpc3RlbmNlID09IFJFTFBFUlNJU1RFTkNFX1RFTVApCkBAIC00MzQ1LDYgKzQzNTcsMTQgQEAg UmVpbmRleFJlbGF0aW9uQ29uY3VycmVudGx5KGNvbnN0IFJlaW5kZXhTdG10ICpzdG10LCBPaWQg cmVsYXRpb25PaWQsIGNvbnN0IFJlaW4KIAkJVW5sb2NrUmVsYXRpb25JZEZvclNlc3Npb24obG9j a3JlbGlkLCBTaGFyZVVwZGF0ZUV4Y2x1c2l2ZUxvY2spOwogCX0KIAorCS8vIG5vdyB3ZSBtYXkg Y2xlYXIgc2FmZSBpbmRleCBidWlsZGluZyBmbGFncworCWZvcmVhY2gobGMsIG5ld0luZGV4SWRz KQorCXsKKwkJUmVpbmRleEluZGV4SW5mbyAqbmV3aWR4ID0gbGZpcnN0KGxjKTsKKwkJaWYgKG5l d2lkeC0+c2FmZSkKKwkJCVVwZGF0ZU51bVNhZmVDb25jdXJyZW50bHlCdWlsdEluZGV4ZXMoZmFs c2UpOworCX0KKwogCS8qIFN0YXJ0IGEgbmV3IHRyYW5zYWN0aW9uIHRvIGZpbmlzaCBwcm9jZXNz IHByb3Blcmx5ICovCiAJU3RhcnRUcmFuc2FjdGlvbkNvbW1hbmQoKTsKIApkaWZmIC0tZ2l0IGEv c3JjL2JhY2tlbmQvc3RvcmFnZS9pcGMvaXBjaS5jIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9pcGMv aXBjaS5jCmluZGV4IDUyMWVkNTQxOGMuLjI2MGE2MzRmMWIgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNr ZW5kL3N0b3JhZ2UvaXBjL2lwY2kuYworKysgYi9zcmMvYmFja2VuZC9zdG9yYWdlL2lwYy9pcGNp LmMKQEAgLTI0LDYgKzI0LDcgQEAKICNpbmNsdWRlICJhY2Nlc3MvdHdvcGhhc2UuaCIKICNpbmNs dWRlICJhY2Nlc3MveGxvZ3ByZWZldGNoZXIuaCIKICNpbmNsdWRlICJhY2Nlc3MveGxvZ3JlY292 ZXJ5LmgiCisjaW5jbHVkZSAiY2F0YWxvZy9pbmRleC5oIgogI2luY2x1ZGUgImNvbW1hbmRzL2Fz eW5jLmgiCiAjaW5jbHVkZSAibWlzY2FkbWluLmgiCiAjaW5jbHVkZSAicGdzdGF0LmgiCkBAIC0z NTcsNiArMzU4LDcgQEAgQ3JlYXRlT3JBdHRhY2hTaG1lbVN0cnVjdHModm9pZCkKIAlTdGF0c1No bWVtSW5pdCgpOwogCVdhaXRFdmVudEV4dGVuc2lvblNobWVtSW5pdCgpOwogCUluamVjdGlvblBv aW50U2htZW1Jbml0KCk7CisJU2FmZUlDU3RhdGVTaG1lbUluaXQoKTsKIH0KIAogLyoKZGlmZiAt LWdpdCBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvaXBjL3Byb2NhcnJheS5jIGIvc3JjL2JhY2tlbmQv c3RvcmFnZS9pcGMvcHJvY2FycmF5LmMKaW5kZXggMWE4M2M0MjIwYi4uNDQ2ZGYzNGRhYiAxMDA2 NDQKLS0tIGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9pcGMvcHJvY2FycmF5LmMKKysrIGIvc3JjL2Jh Y2tlbmQvc3RvcmFnZS9pcGMvcHJvY2FycmF5LmMKQEAgLTUzLDYgKzUzLDcgQEAKICNpbmNsdWRl ICJhY2Nlc3MveGFjdC5oIgogI2luY2x1ZGUgImFjY2Vzcy94bG9ndXRpbHMuaCIKICNpbmNsdWRl ICJjYXRhbG9nL2NhdGFsb2cuaCIKKyNpbmNsdWRlICJjYXRhbG9nL2luZGV4LmgiCiAjaW5jbHVk ZSAiY2F0YWxvZy9wZ19hdXRoaWQuaCIKICNpbmNsdWRlICJjb21tYW5kcy9kYmNvbW1hbmRzLmgi CiAjaW5jbHVkZSAibWlzY2FkbWluLmgiCkBAIC0yMzYsNiArMjM3LDEyIEBAIHR5cGVkZWYgc3Ry dWN0IENvbXB1dGVYaWRIb3Jpem9uc1Jlc3VsdAogCSAqLwogCVRyYW5zYWN0aW9uSWQgZGF0YV9v bGRlc3Rfbm9ucmVtb3ZhYmxlOwogCisJLyoKKwkgKiBPbGRlc3QgeGlkIGZvciB3aGljaCBkZWxl dGVkIHR1cGxlcyBuZWVkIHRvIGJlIHJldGFpbmVkIGluIG5vcm1hbCB1c2VyCisJICogZGVmaW5l ZCB0YWJsZXMgd2l0aCBpbmRleCBidWlsZGluZyBpbiBwcm9ncmVzcyBieSBwcm9jZXNzIHdpdGgg UFJPQ19JTlNBRkVfSUMuCisJICovCisJVHJhbnNhY3Rpb25JZCBkYXRhX3NhZmVfaWNfb2xkZXN0 X25vbnJlbW92YWJsZTsKKwogCS8qCiAJICogT2xkZXN0IHhpZCBmb3Igd2hpY2ggZGVsZXRlZCB0 dXBsZXMgbmVlZCB0byBiZSByZXRhaW5lZCBpbiB0aGlzCiAJICogc2Vzc2lvbidzIHRlbXBvcmFy eSB0YWJsZXMuCkBAIC0yNTEsNiArMjU4LDcgQEAgdHlwZWRlZiBlbnVtIEdsb2JhbFZpc0hvcml6 b25LaW5kCiAJVklTSE9SSVpPTl9TSEFSRUQsCiAJVklTSE9SSVpPTl9DQVRBTE9HLAogCVZJU0hP UklaT05fREFUQSwKKwlWSVNIT1JJWk9OX0RBVEFfU0FGRV9JQywKIAlWSVNIT1JJWk9OX1RFTVAs CiB9IEdsb2JhbFZpc0hvcml6b25LaW5kOwogCkBAIC0yOTcsNiArMzA1LDcgQEAgc3RhdGljIFRy YW5zYWN0aW9uSWQgc3RhbmRieVNuYXBzaG90UGVuZGluZ1htaW47CiBzdGF0aWMgR2xvYmFsVmlz U3RhdGUgR2xvYmFsVmlzU2hhcmVkUmVsczsKIHN0YXRpYyBHbG9iYWxWaXNTdGF0ZSBHbG9iYWxW aXNDYXRhbG9nUmVsczsKIHN0YXRpYyBHbG9iYWxWaXNTdGF0ZSBHbG9iYWxWaXNEYXRhUmVsczsK K3N0YXRpYyBHbG9iYWxWaXNTdGF0ZSBHbG9iYWxWaXNEYXRhU2FmZUljUmVsczsKIHN0YXRpYyBH bG9iYWxWaXNTdGF0ZSBHbG9iYWxWaXNUZW1wUmVsczsKIAogLyoKQEAgLTE3MjcsOSArMTczNiw2 IEBAIENvbXB1dGVYaWRIb3Jpem9ucyhDb21wdXRlWGlkSG9yaXpvbnNSZXN1bHQgKmgpCiAJYm9v bAkJaW5fcmVjb3ZlcnkgPSBSZWNvdmVyeUluUHJvZ3Jlc3MoKTsKIAlUcmFuc2FjdGlvbklkICpv dGhlcl94aWRzID0gUHJvY0dsb2JhbC0+eGlkczsKIAotCS8qIGluZmVycmVkIGFmdGVyIFByb2NB cnJheUxvY2sgaXMgcmVsZWFzZWQgKi8KLQloLT5jYXRhbG9nX29sZGVzdF9ub25yZW1vdmFibGUg PSBJbnZhbGlkVHJhbnNhY3Rpb25JZDsKLQogCUxXTG9ja0FjcXVpcmUoUHJvY0FycmF5TG9jaywg TFdfU0hBUkVEKTsKIAogCWgtPmxhdGVzdF9jb21wbGV0ZWQgPSBUcmFuc2FtVmFyaWFibGVzLT5s YXRlc3RDb21wbGV0ZWRYaWQ7CkBAIC0xNzQ5LDcgKzE3NTUsOSBAQCBDb21wdXRlWGlkSG9yaXpv bnMoQ29tcHV0ZVhpZEhvcml6b25zUmVzdWx0ICpoKQogCiAJCWgtPm9sZGVzdF9jb25zaWRlcmVk X3J1bm5pbmcgPSBpbml0aWFsOwogCQloLT5zaGFyZWRfb2xkZXN0X25vbnJlbW92YWJsZSA9IGlu aXRpYWw7CisJCWgtPmNhdGFsb2dfb2xkZXN0X25vbnJlbW92YWJsZSA9IGluaXRpYWw7CiAJCWgt PmRhdGFfb2xkZXN0X25vbnJlbW92YWJsZSA9IGluaXRpYWw7CisJCWgtPmRhdGFfc2FmZV9pY19v bGRlc3Rfbm9ucmVtb3ZhYmxlID0gaW5pdGlhbDsKIAogCQkvKgogCQkgKiBPbmx5IG1vZGlmaWNh dGlvbnMgbWFkZSBieSB0aGlzIGJhY2tlbmQgYWZmZWN0IHRoZSBob3Jpem9uIGZvcgpAQCAtMTg0 NywxMSArMTg1NSwyOCBAQCBDb21wdXRlWGlkSG9yaXpvbnMoQ29tcHV0ZVhpZEhvcml6b25zUmVz dWx0ICpoKQogCQkJKHN0YXR1c0ZsYWdzICYgUFJPQ19BRkZFQ1RTX0FMTF9IT1JJWk9OUykgfHwK IAkJCWluX3JlY292ZXJ5KQogCQl7Ci0JCQloLT5kYXRhX29sZGVzdF9ub25yZW1vdmFibGUgPQot CQkJCVRyYW5zYWN0aW9uSWRPbGRlcihoLT5kYXRhX29sZGVzdF9ub25yZW1vdmFibGUsIHhtaW4p OworCQkJaC0+ZGF0YV9zYWZlX2ljX29sZGVzdF9ub25yZW1vdmFibGUgPQorCQkJCQlUcmFuc2Fj dGlvbklkT2xkZXIoaC0+ZGF0YV9zYWZlX2ljX29sZGVzdF9ub25yZW1vdmFibGUsIHhtaW4pOwor CisJCQlpZiAoIShzdGF0dXNGbGFncyAmIFBST0NfSU5fU0FGRV9JQykpCisJCQkJaC0+ZGF0YV9v bGRlc3Rfbm9ucmVtb3ZhYmxlID0KKwkJCQkJVHJhbnNhY3Rpb25JZE9sZGVyKGgtPmRhdGFfb2xk ZXN0X25vbnJlbW92YWJsZSwgeG1pbik7CisKKwkJCS8qIENhdGFsb2cgdGFibGVzIG5lZWQgdG8g Y29uc2lkZXIgYWxsIGJhY2tlbmRzIGluIHRoaXMgZGIgKi8KKwkJCWgtPmNhdGFsb2dfb2xkZXN0 X25vbnJlbW92YWJsZSA9CisJCQkJVHJhbnNhY3Rpb25JZE9sZGVyKGgtPmNhdGFsb2dfb2xkZXN0 X25vbnJlbW92YWJsZSwgeG1pbik7CisKIAkJfQogCX0KIAorCS8qIGNhdGFsb2cgaG9yaXpvbiBz aG91bGQgbmV2ZXIgYmUgbGF0ZXIgdGhhbiBkYXRhICovCisJQXNzZXJ0KFRyYW5zYWN0aW9uSWRQ cmVjZWRlc09yRXF1YWxzKGgtPmNhdGFsb2dfb2xkZXN0X25vbnJlbW92YWJsZSwKKwkJCQkJCQkJ CQkgaC0+ZGF0YV9vbGRlc3Rfbm9ucmVtb3ZhYmxlKSk7CisKKwkvKiBkYXRhIGhvcml6b24gc2hv dWxkIG5ldmVyIGJlIGxhdGVyIHRoYW4gc2FmZSBpbmRleCBidWlsZGluZyBob3Jpem9uICovCisJ QXNzZXJ0KFRyYW5zYWN0aW9uSWRQcmVjZWRlc09yRXF1YWxzKGgtPmRhdGFfc2FmZV9pY19vbGRl c3Rfbm9ucmVtb3ZhYmxlLAorCQkJCQkJCQkJCSBoLT5kYXRhX29sZGVzdF9ub25yZW1vdmFibGUp KTsKKwogCS8qCiAJICogSWYgaW4gcmVjb3ZlcnkgZmV0Y2ggb2xkZXN0IHhpZCBpbiBLbm93bkFz c2lnbmVkWGlkcywgd2lsbCBiZSBhcHBsaWVkCiAJICogYWZ0ZXIgbG9jayBpcyByZWxlYXNlZC4K QEAgLTE4NzMsNiArMTg5OCwxMCBAQCBDb21wdXRlWGlkSG9yaXpvbnMoQ29tcHV0ZVhpZEhvcml6 b25zUmVzdWx0ICpoKQogCQkJVHJhbnNhY3Rpb25JZE9sZGVyKGgtPnNoYXJlZF9vbGRlc3Rfbm9u cmVtb3ZhYmxlLCBrYXhtaW4pOwogCQloLT5kYXRhX29sZGVzdF9ub25yZW1vdmFibGUgPQogCQkJ VHJhbnNhY3Rpb25JZE9sZGVyKGgtPmRhdGFfb2xkZXN0X25vbnJlbW92YWJsZSwga2F4bWluKTsK KwkJaC0+ZGF0YV9zYWZlX2ljX29sZGVzdF9ub25yZW1vdmFibGUgPQorCQkJCVRyYW5zYWN0aW9u SWRPbGRlcihoLT5kYXRhX3NhZmVfaWNfb2xkZXN0X25vbnJlbW92YWJsZSwga2F4bWluKTsKKwkJ aC0+Y2F0YWxvZ19vbGRlc3Rfbm9ucmVtb3ZhYmxlID0KKwkJCVRyYW5zYWN0aW9uSWRPbGRlciho LT5jYXRhbG9nX29sZGVzdF9ub25yZW1vdmFibGUsIGtheG1pbik7CiAJCS8qIHRlbXAgcmVsYXRp b25zIGNhbm5vdCBiZSBhY2Nlc3NlZCBpbiByZWNvdmVyeSAqLwogCX0KIApAQCAtMTg4MCw2ICsx OTA5LDggQEAgQ29tcHV0ZVhpZEhvcml6b25zKENvbXB1dGVYaWRIb3Jpem9uc1Jlc3VsdCAqaCkK IAkJCQkJCQkJCQkgaC0+c2hhcmVkX29sZGVzdF9ub25yZW1vdmFibGUpKTsKIAlBc3NlcnQoVHJh bnNhY3Rpb25JZFByZWNlZGVzT3JFcXVhbHMoaC0+c2hhcmVkX29sZGVzdF9ub25yZW1vdmFibGUs CiAJCQkJCQkJCQkJIGgtPmRhdGFfb2xkZXN0X25vbnJlbW92YWJsZSkpOworCUFzc2VydChUcmFu c2FjdGlvbklkUHJlY2VkZXNPckVxdWFscyhoLT5zaGFyZWRfb2xkZXN0X25vbnJlbW92YWJsZSwK KwkJCQkJCQkJCQkgaC0+ZGF0YV9zYWZlX2ljX29sZGVzdF9ub25yZW1vdmFibGUpKTsKIAogCS8q CiAJICogQ2hlY2sgd2hldGhlciB0aGVyZSBhcmUgcmVwbGljYXRpb24gc2xvdHMgcmVxdWlyaW5n IGFuIG9sZGVyIHhtaW4uCkBAIC0xODg4LDYgKzE5MTksOCBAQCBDb21wdXRlWGlkSG9yaXpvbnMo Q29tcHV0ZVhpZEhvcml6b25zUmVzdWx0ICpoKQogCQlUcmFuc2FjdGlvbklkT2xkZXIoaC0+c2hh cmVkX29sZGVzdF9ub25yZW1vdmFibGUsIGgtPnNsb3RfeG1pbik7CiAJaC0+ZGF0YV9vbGRlc3Rf bm9ucmVtb3ZhYmxlID0KIAkJVHJhbnNhY3Rpb25JZE9sZGVyKGgtPmRhdGFfb2xkZXN0X25vbnJl bW92YWJsZSwgaC0+c2xvdF94bWluKTsKKwloLT5kYXRhX3NhZmVfaWNfb2xkZXN0X25vbnJlbW92 YWJsZSA9CisJCQlUcmFuc2FjdGlvbklkT2xkZXIoaC0+ZGF0YV9zYWZlX2ljX29sZGVzdF9ub25y ZW1vdmFibGUsIGgtPnNsb3RfeG1pbik7CiAKIAkvKgogCSAqIFRoZSBvbmx5IGRpZmZlcmVuY2Ug YmV0d2VlbiBjYXRhbG9nIC8gZGF0YSBob3Jpem9ucyBpcyB0aGF0IHRoZSBzbG90J3MKQEAgLTE5 MDAsNyArMTkzMyw5IEBAIENvbXB1dGVYaWRIb3Jpem9ucyhDb21wdXRlWGlkSG9yaXpvbnNSZXN1 bHQgKmgpCiAJaC0+c2hhcmVkX29sZGVzdF9ub25yZW1vdmFibGUgPQogCQlUcmFuc2FjdGlvbklk T2xkZXIoaC0+c2hhcmVkX29sZGVzdF9ub25yZW1vdmFibGUsCiAJCQkJCQkgICBoLT5zbG90X2Nh dGFsb2dfeG1pbik7Ci0JaC0+Y2F0YWxvZ19vbGRlc3Rfbm9ucmVtb3ZhYmxlID0gaC0+ZGF0YV9v bGRlc3Rfbm9ucmVtb3ZhYmxlOworCWgtPmNhdGFsb2dfb2xkZXN0X25vbnJlbW92YWJsZSA9CisJ CVRyYW5zYWN0aW9uSWRPbGRlcihoLT5jYXRhbG9nX29sZGVzdF9ub25yZW1vdmFibGUsCisJCQkJ CQkgICBoLT5zbG90X3htaW4pOwogCWgtPmNhdGFsb2dfb2xkZXN0X25vbnJlbW92YWJsZSA9CiAJ CVRyYW5zYWN0aW9uSWRPbGRlcihoLT5jYXRhbG9nX29sZGVzdF9ub25yZW1vdmFibGUsCiAJCQkJ CQkgICBoLT5zbG90X2NhdGFsb2dfeG1pbik7CkBAIC0xOTE4LDYgKzE5NTMsOSBAQCBDb21wdXRl WGlkSG9yaXpvbnMoQ29tcHV0ZVhpZEhvcml6b25zUmVzdWx0ICpoKQogCWgtPm9sZGVzdF9jb25z aWRlcmVkX3J1bm5pbmcgPQogCQlUcmFuc2FjdGlvbklkT2xkZXIoaC0+b2xkZXN0X2NvbnNpZGVy ZWRfcnVubmluZywKIAkJCQkJCSAgIGgtPmRhdGFfb2xkZXN0X25vbnJlbW92YWJsZSk7CisJaC0+ b2xkZXN0X2NvbnNpZGVyZWRfcnVubmluZyA9CisJCQlUcmFuc2FjdGlvbklkT2xkZXIoaC0+b2xk ZXN0X2NvbnNpZGVyZWRfcnVubmluZywKKwkJCQkJCQkgICBoLT5kYXRhX3NhZmVfaWNfb2xkZXN0 X25vbnJlbW92YWJsZSk7CiAKIAkvKgogCSAqIHNoYXJlZCBob3Jpem9ucyBoYXZlIHRvIGJlIGF0 IGxlYXN0IGFzIG9sZCBhcyB0aGUgb2xkZXN0IHZpc2libGUgaW4KQEAgLTE5MjUsNiArMTk2Myw4 IEBAIENvbXB1dGVYaWRIb3Jpem9ucyhDb21wdXRlWGlkSG9yaXpvbnNSZXN1bHQgKmgpCiAJICov CiAJQXNzZXJ0KFRyYW5zYWN0aW9uSWRQcmVjZWRlc09yRXF1YWxzKGgtPnNoYXJlZF9vbGRlc3Rf bm9ucmVtb3ZhYmxlLAogCQkJCQkJCQkJCSBoLT5kYXRhX29sZGVzdF9ub25yZW1vdmFibGUpKTsK KwlBc3NlcnQoVHJhbnNhY3Rpb25JZFByZWNlZGVzT3JFcXVhbHMoaC0+c2hhcmVkX29sZGVzdF9u b25yZW1vdmFibGUsCisJCQkJCQkJCQkJIGgtPmRhdGFfc2FmZV9pY19vbGRlc3Rfbm9ucmVtb3Zh YmxlKSk7CiAJQXNzZXJ0KFRyYW5zYWN0aW9uSWRQcmVjZWRlc09yRXF1YWxzKGgtPnNoYXJlZF9v bGRlc3Rfbm9ucmVtb3ZhYmxlLAogCQkJCQkJCQkJCSBoLT5jYXRhbG9nX29sZGVzdF9ub25yZW1v dmFibGUpKTsKIApAQCAtMTkzOCw2ICsxOTc4LDggQEAgQ29tcHV0ZVhpZEhvcml6b25zKENvbXB1 dGVYaWRIb3Jpem9uc1Jlc3VsdCAqaCkKIAkJCQkJCQkJCQkgaC0+Y2F0YWxvZ19vbGRlc3Rfbm9u cmVtb3ZhYmxlKSk7CiAJQXNzZXJ0KFRyYW5zYWN0aW9uSWRQcmVjZWRlc09yRXF1YWxzKGgtPm9s ZGVzdF9jb25zaWRlcmVkX3J1bm5pbmcsCiAJCQkJCQkJCQkJIGgtPmRhdGFfb2xkZXN0X25vbnJl bW92YWJsZSkpOworCUFzc2VydChUcmFuc2FjdGlvbklkUHJlY2VkZXNPckVxdWFscyhoLT5vbGRl c3RfY29uc2lkZXJlZF9ydW5uaW5nLAorCQkJCQkJCQkJCSBoLT5kYXRhX3NhZmVfaWNfb2xkZXN0 X25vbnJlbW92YWJsZSkpOwogCUFzc2VydChUcmFuc2FjdGlvbklkUHJlY2VkZXNPckVxdWFscyho LT5vbGRlc3RfY29uc2lkZXJlZF9ydW5uaW5nLAogCQkJCQkJCQkJCSBoLT50ZW1wX29sZGVzdF9u b25yZW1vdmFibGUpKTsKIAlBc3NlcnQoIVRyYW5zYWN0aW9uSWRJc1ZhbGlkKGgtPnNsb3RfeG1p bikgfHwKQEAgLTE5NzMsNyArMjAxNSwyMSBAQCBHbG9iYWxWaXNIb3Jpem9uS2luZEZvclJlbChS ZWxhdGlvbiByZWwpCiAJCQkgUmVsYXRpb25Jc0FjY2Vzc2libGVJbkxvZ2ljYWxEZWNvZGluZyhy ZWwpKQogCQlyZXR1cm4gVklTSE9SSVpPTl9DQVRBTE9HOwogCWVsc2UgaWYgKCFSRUxBVElPTl9J U19MT0NBTChyZWwpKQorCXsKKwkJLy8gVE9ETzogZG8gd2UgbmVlZCB0byBkbyBzb21ldGhpbmcg c3BlY2lhbCBhYm91dCB0aGUgVE9BU1Q/CisJCWlmICghcmVsLT5yZF9pbmRleHZhbGlkKQorCQl7 CisJCQkvLyBza2lwIGxvYWRpbmcgaW5kZXhlcyBpZiB3ZSBrbm93IHRoZXJlIGlzIG5vdCBzYWZl IGNvbmN1cnJlbnQgaW5kZXggYnVpbGRzIGluIHRoZSBjbHVzdGVyCisJCQlpZiAoSXNBbnlTYWZl SW5kZXhCdWlsZHNDb25jdXJyZW50bHkoKSkKKwkJCXsKKwkJCQlSZWxhdGlvbkdldEluZGV4TGlz dChyZWwpOworCQkJCUFzc2VydChyZWwtPnJkX2luZGV4dmFsaWQpOworCQkJfSBlbHNlIHJldHVy biBWSVNIT1JJWk9OX0RBVEE7CisJCX0KKwkJaWYgKHJlbC0+cmRfc2FmZWluZGV4Y29uY3VycmVu dGx5YnVpbGRpbmcpCisJCQlyZXR1cm4gVklTSE9SSVpPTl9EQVRBX1NBRkVfSUM7CiAJCXJldHVy biBWSVNIT1JJWk9OX0RBVEE7CisJfQogCWVsc2UKIAkJcmV0dXJuIFZJU0hPUklaT05fVEVNUDsK IH0KQEAgLTIwMDQsNiArMjA2MCw4IEBAIEdldE9sZGVzdE5vblJlbW92YWJsZVRyYW5zYWN0aW9u SWQoUmVsYXRpb24gcmVsKQogCQkJcmV0dXJuIGhvcml6b25zLmNhdGFsb2dfb2xkZXN0X25vbnJl bW92YWJsZTsKIAkJY2FzZSBWSVNIT1JJWk9OX0RBVEE6CiAJCQlyZXR1cm4gaG9yaXpvbnMuZGF0 YV9vbGRlc3Rfbm9ucmVtb3ZhYmxlOworCQljYXNlIFZJU0hPUklaT05fREFUQV9TQUZFX0lDOgor CQkJcmV0dXJuIGhvcml6b25zLmRhdGFfc2FmZV9pY19vbGRlc3Rfbm9ucmVtb3ZhYmxlOwogCQlj YXNlIFZJU0hPUklaT05fVEVNUDoKIAkJCXJldHVybiBob3Jpem9ucy50ZW1wX29sZGVzdF9ub25y ZW1vdmFibGU7CiAJfQpAQCAtMjQ1NCw2ICsyNTEyLDkgQEAgR2V0U25hcHNob3REYXRhKFNuYXBz aG90IHNuYXBzaG90KQogCQlHbG9iYWxWaXNEYXRhUmVscy5kZWZpbml0ZWx5X25lZWRlZCA9CiAJ CQlGdWxsVHJhbnNhY3Rpb25JZE5ld2VyKGRlZl92aXNfZnhpZF9kYXRhLAogCQkJCQkJCQkgICBH bG9iYWxWaXNEYXRhUmVscy5kZWZpbml0ZWx5X25lZWRlZCk7CisJCUdsb2JhbFZpc0RhdGFTYWZl SWNSZWxzLmRlZmluaXRlbHlfbmVlZGVkID0KKwkJCQlGdWxsVHJhbnNhY3Rpb25JZE5ld2VyKGRl Zl92aXNfZnhpZF9kYXRhLAorCQkJCQkJCQkJICAgR2xvYmFsVmlzRGF0YVNhZmVJY1JlbHMuZGVm aW5pdGVseV9uZWVkZWQpOwogCQkvKiBTZWUgdGVtcF9vbGRlc3Rfbm9ucmVtb3ZhYmxlIGNvbXB1 dGF0aW9uIGluIENvbXB1dGVYaWRIb3Jpem9ucygpICovCiAJCWlmIChUcmFuc2FjdGlvbklkSXNO b3JtYWwobXl4aWQpKQogCQkJR2xvYmFsVmlzVGVtcFJlbHMuZGVmaW5pdGVseV9uZWVkZWQgPQpA QCAtMjQ3OCw2ICsyNTM5LDkgQEAgR2V0U25hcHNob3REYXRhKFNuYXBzaG90IHNuYXBzaG90KQog CQlHbG9iYWxWaXNDYXRhbG9nUmVscy5tYXliZV9uZWVkZWQgPQogCQkJRnVsbFRyYW5zYWN0aW9u SWROZXdlcihHbG9iYWxWaXNDYXRhbG9nUmVscy5tYXliZV9uZWVkZWQsCiAJCQkJCQkJCSAgIG9s ZGVzdGZ4aWQpOworCQlHbG9iYWxWaXNEYXRhU2FmZUljUmVscy5tYXliZV9uZWVkZWQgPQorCQkJ CUZ1bGxUcmFuc2FjdGlvbklkTmV3ZXIoR2xvYmFsVmlzRGF0YVNhZmVJY1JlbHMubWF5YmVfbmVl ZGVkLAorCQkJCQkJCQkJICAgb2xkZXN0ZnhpZCk7CiAJCUdsb2JhbFZpc0RhdGFSZWxzLm1heWJl X25lZWRlZCA9CiAJCQlGdWxsVHJhbnNhY3Rpb25JZE5ld2VyKEdsb2JhbFZpc0RhdGFSZWxzLm1h eWJlX25lZWRlZCwKIAkJCQkJCQkJICAgb2xkZXN0ZnhpZCk7CkBAIC00MTA2LDYgKzQxNzAsOSBA QCBHbG9iYWxWaXNUZXN0Rm9yKFJlbGF0aW9uIHJlbCkKIAkJY2FzZSBWSVNIT1JJWk9OX0RBVEE6 CiAJCQlzdGF0ZSA9ICZHbG9iYWxWaXNEYXRhUmVsczsKIAkJCWJyZWFrOworCQljYXNlIFZJU0hP UklaT05fREFUQV9TQUZFX0lDOgorCQkJc3RhdGUgPSAmR2xvYmFsVmlzRGF0YVNhZmVJY1JlbHM7 CisJCQlicmVhazsKIAkJY2FzZSBWSVNIT1JJWk9OX1RFTVA6CiAJCQlzdGF0ZSA9ICZHbG9iYWxW aXNUZW1wUmVsczsKIAkJCWJyZWFrOwpAQCAtNDE1OCw2ICs0MjI1LDkgQEAgR2xvYmFsVmlzVXBk YXRlQXBwbHkoQ29tcHV0ZVhpZEhvcml6b25zUmVzdWx0ICpob3Jpem9ucykKIAlHbG9iYWxWaXNE YXRhUmVscy5tYXliZV9uZWVkZWQgPQogCQlGdWxsWGlkUmVsYXRpdmVUbyhob3Jpem9ucy0+bGF0 ZXN0X2NvbXBsZXRlZCwKIAkJCQkJCSAgaG9yaXpvbnMtPmRhdGFfb2xkZXN0X25vbnJlbW92YWJs ZSk7CisJR2xvYmFsVmlzRGF0YVNhZmVJY1JlbHMubWF5YmVfbmVlZGVkID0KKwkJCUZ1bGxYaWRS ZWxhdGl2ZVRvKGhvcml6b25zLT5sYXRlc3RfY29tcGxldGVkLAorCQkJCQkJCSAgaG9yaXpvbnMt PmRhdGFfc2FmZV9pY19vbGRlc3Rfbm9ucmVtb3ZhYmxlKTsKIAlHbG9iYWxWaXNUZW1wUmVscy5t YXliZV9uZWVkZWQgPQogCQlGdWxsWGlkUmVsYXRpdmVUbyhob3Jpem9ucy0+bGF0ZXN0X2NvbXBs ZXRlZCwKIAkJCQkJCSAgaG9yaXpvbnMtPnRlbXBfb2xkZXN0X25vbnJlbW92YWJsZSk7CkBAIC00 MTc2LDYgKzQyNDYsOSBAQCBHbG9iYWxWaXNVcGRhdGVBcHBseShDb21wdXRlWGlkSG9yaXpvbnNS ZXN1bHQgKmhvcml6b25zKQogCUdsb2JhbFZpc0RhdGFSZWxzLmRlZmluaXRlbHlfbmVlZGVkID0K IAkJRnVsbFRyYW5zYWN0aW9uSWROZXdlcihHbG9iYWxWaXNEYXRhUmVscy5tYXliZV9uZWVkZWQs CiAJCQkJCQkJICAgR2xvYmFsVmlzRGF0YVJlbHMuZGVmaW5pdGVseV9uZWVkZWQpOworCUdsb2Jh bFZpc0RhdGFTYWZlSWNSZWxzLmRlZmluaXRlbHlfbmVlZGVkID0KKwkJCUZ1bGxUcmFuc2FjdGlv bklkTmV3ZXIoR2xvYmFsVmlzRGF0YVNhZmVJY1JlbHMubWF5YmVfbmVlZGVkLAorCQkJCQkJCQkg ICBHbG9iYWxWaXNEYXRhU2FmZUljUmVscy5kZWZpbml0ZWx5X25lZWRlZCk7CiAJR2xvYmFsVmlz VGVtcFJlbHMuZGVmaW5pdGVseV9uZWVkZWQgPSBHbG9iYWxWaXNUZW1wUmVscy5tYXliZV9uZWVk ZWQ7CiAKIAlDb21wdXRlWGlkSG9yaXpvbnNSZXN1bHRMYXN0WG1pbiA9IFJlY2VudFhtaW47CmRp ZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9jYWNoZS9yZWxjYWNoZS5jIGIvc3JjL2JhY2tl bmQvdXRpbHMvY2FjaGUvcmVsY2FjaGUuYwppbmRleCAyNjJjOTg3OGRkLi45M2I3Nzk0YjQ4IDEw MDY0NAotLS0gYS9zcmMvYmFja2VuZC91dGlscy9jYWNoZS9yZWxjYWNoZS5jCisrKyBiL3NyYy9i YWNrZW5kL3V0aWxzL2NhY2hlL3JlbGNhY2hlLmMKQEAgLTQxLDYgKzQxLDcgQEAKICNpbmNsdWRl ICJhY2Nlc3MveGFjdC5oIgogI2luY2x1ZGUgImNhdGFsb2cvYmluYXJ5X3VwZ3JhZGUuaCIKICNp bmNsdWRlICJjYXRhbG9nL2NhdGFsb2cuaCIKKyNpbmNsdWRlICJjYXRhbG9nL2luZGV4LmgiCiAj aW5jbHVkZSAiY2F0YWxvZy9pbmRleGluZy5oIgogI2luY2x1ZGUgImNhdGFsb2cvbmFtZXNwYWNl LmgiCiAjaW5jbHVkZSAiY2F0YWxvZy9wYXJ0aXRpb24uaCIKQEAgLTQ3NjksNiArNDc3MCw3IEBA IFJlbGF0aW9uR2V0SW5kZXhMaXN0KFJlbGF0aW9uIHJlbGF0aW9uKQogCU9pZAkJCXBrZXlJbmRl eCA9IEludmFsaWRPaWQ7CiAJT2lkCQkJY2FuZGlkYXRlSW5kZXggPSBJbnZhbGlkT2lkOwogCWJv b2wJCXBrZGVmZXJyYWJsZSA9IGZhbHNlOworCWJvb2wgCQlzYWZlaW5kZXhjb25jdXJyZW50bHli dWlsZGluZyA9IGZhbHNlOwogCU1lbW9yeUNvbnRleHQgb2xkY3h0OwogCiAJLyogUXVpY2sgZXhp dCBpZiB3ZSBhbHJlYWR5IGNvbXB1dGVkIHRoZSBsaXN0LiAqLwpAQCAtNDgwOSw2ICs0ODExLDE0 IEBAIFJlbGF0aW9uR2V0SW5kZXhMaXN0KFJlbGF0aW9uIHJlbGF0aW9uKQogCQkvKiBhZGQgaW5k ZXgncyBPSUQgdG8gcmVzdWx0IGxpc3QgKi8KIAkJcmVzdWx0ID0gbGFwcGVuZF9vaWQocmVzdWx0 LCBpbmRleC0+aW5kZXhyZWxpZCk7CiAKKwkJLyoKKwkJICogQ29uc2lkZXIgaW5kZXggYXMgYnVp bGRpbmcgaWYgaXQgaXMgbm90IHlldCB2YWxpZC4KKwkJICogQWxzbywgd2UgbXVzdCBkZWFsIG9u bHkgd2l0aCBpbmRleGVzIHdoaWNoIGFyZSBidWlsdCB1c2luZyB0aGUKKwkJICogY29uY3VycmVu dCBzYWZlIG1vZGUuCisJCSAqLworCQlpZiAoIWluZGV4LT5pbmRpc3ZhbGlkKQorCQkJc2FmZWlu ZGV4Y29uY3VycmVudGx5YnVpbGRpbmcgfD0gSXNBbnlTYWZlSW5kZXhCdWlsZHNDb25jdXJyZW50 bHkoKTsKKwogCQkvKgogCQkgKiBOb24tdW5pcXVlIG9yIHByZWRpY2F0ZSBpbmRleGVzIGFyZW4n dCBpbnRlcmVzdGluZyBmb3IgZWl0aGVyIG9pZAogCQkgKiBpbmRleGVzIG9yIHJlcGxpY2F0aW9u IGlkZW50aXR5IGluZGV4ZXMsIHNvIGRvbid0IGNoZWNrIHRoZW0uCkBAIC00ODY5LDYgKzQ4Nzks NyBAQCBSZWxhdGlvbkdldEluZGV4TGlzdChSZWxhdGlvbiByZWxhdGlvbikKIAlyZWxhdGlvbi0+ cmRfaW5kZXhsaXN0ID0gbGlzdF9jb3B5KHJlc3VsdCk7CiAJcmVsYXRpb24tPnJkX3BraW5kZXgg PSBwa2V5SW5kZXg7CiAJcmVsYXRpb24tPnJkX2lzcGtkZWZlcnJhYmxlID0gcGtkZWZlcnJhYmxl OworCXJlbGF0aW9uLT5yZF9zYWZlaW5kZXhjb25jdXJyZW50bHlidWlsZGluZyA9IHNhZmVpbmRl eGNvbmN1cnJlbnRseWJ1aWxkaW5nOwogCWlmIChyZXBsaWRlbnQgPT0gUkVQTElDQV9JREVOVElU WV9ERUZBVUxUICYmIE9pZElzVmFsaWQocGtleUluZGV4KSAmJiAhcGtkZWZlcnJhYmxlKQogCQly ZWxhdGlvbi0+cmRfcmVwbGlkaW5kZXggPSBwa2V5SW5kZXg7CiAJZWxzZSBpZiAocmVwbGlkZW50 ID09IFJFUExJQ0FfSURFTlRJVFlfSU5ERVggJiYgT2lkSXNWYWxpZChjYW5kaWRhdGVJbmRleCkp CmRpZmYgLS1naXQgYS9zcmMvYmluL3BnX2FtY2hlY2svdC8wMDZfY29uY3VycmVudGx5LnBsIGIv c3JjL2Jpbi9wZ19hbWNoZWNrL3QvMDA2X2NvbmN1cnJlbnRseS5wbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwLi43YjhhZmVlYWQ1Ci0tLSAvZGV2L251bGwKKysrIGIvc3Jj L2Jpbi9wZ19hbWNoZWNrL3QvMDA2X2NvbmN1cnJlbnRseS5wbApAQCAtMCwwICsxLDE1NSBAQAor CisjIENvcHlyaWdodCAoYykgMjAyNCwgUG9zdGdyZVNRTCBHbG9iYWwgRGV2ZWxvcG1lbnQgR3Jv dXAKKworIyBUZXN0IFJFSU5ERVggQ09OQ1VSUkVOVExZIHdpdGggY29uY3VycmVudCBtb2RpZmlj YXRpb25zIGFuZCBIT1QgdXBkYXRlcwordXNlIHN0cmljdDsKK3VzZSB3YXJuaW5nczsKKwordXNl IENvbmZpZzsKK3VzZSBFcnJubzsKKwordXNlIFBvc3RncmVTUUw6OlRlc3Q6OkNsdXN0ZXI7Cit1 c2UgUG9zdGdyZVNRTDo6VGVzdDo6VXRpbHM7Cit1c2UgVGltZTo6SGlSZXMgcXcodXNsZWVwKTsK K3VzZSBJUEM6OlN5c1Y7Cit1c2UgdGhyZWFkczsKK3VzZSBUZXN0OjpNb3JlOwordXNlIFRlc3Q6 OkJ1aWxkZXI7CisKK2lmICgkQCB8fCAkd2luZG93c19vcykKK3sKKwlwbGFuIHNraXBfYWxsID0+ ICdGb3JrIGFuZCBzaGFyZWQgbWVtb3J5IGFyZSBub3Qgc3VwcG9ydGVkIGJ5IHRoaXMgcGxhdGZv cm0nOworfQorCisjIFRPRE86IHJlZmFjdG9yIHRvIGh0dHBzOi8vbWV0YWNwYW4ub3JnL3BvZC9J UEMlM0ElM0FTaGFyZWFibGUKK215ICgkcGlkLCAkc2htZW1faWQsICRzaG1lbV9rZXksICAkc2ht ZW1fc2l6ZSk7CitldmFsICdzdWIgSVBDX0NSRUFUIHswMDAxMDAwfScgdW5sZXNzIGRlZmluZWQg JklQQ19DUkVBVDsKKyRzaG1lbV9zaXplID0gNDsKKyRzaG1lbV9rZXkgPSByYW5kKDEwMDAwMDAp OworJHNobWVtX2lkID0gc2htZ2V0KCRzaG1lbV9rZXksICRzaG1lbV9zaXplLCAmSVBDX0NSRUFU IHwgMDc3Nykgb3IgZGllICJDYW4ndCBzaG1nZXQ6ICQhIjsKK3NobXdyaXRlKCRzaG1lbV9pZCwg IndhaXQiLCAwLCAkc2htZW1fc2l6ZSkgb3IgZGllICJDYW4ndCBzaG13cml0ZTogJCEiOworCitt eSAkcHNxbF90aW1lb3V0ID0gSVBDOjpSdW46OnRpbWVyKCRQb3N0Z3JlU1FMOjpUZXN0OjpVdGls czo6dGltZW91dF9kZWZhdWx0KTsKKyMKKyMgVGVzdCBzZXQtdXAKKyMKK215ICgkbm9kZSwgJHJl c3VsdCk7Ciskbm9kZSA9IFBvc3RncmVTUUw6OlRlc3Q6OkNsdXN0ZXItPm5ldygnUkNfdGVzdCcp OworJG5vZGUtPmluaXQ7Ciskbm9kZS0+YXBwZW5kX2NvbmYoJ3Bvc3RncmVzcWwuY29uZicsCisJ J2xvY2tfdGltZW91dCA9ICcgLiAoMTAwMCAqICRQb3N0Z3JlU1FMOjpUZXN0OjpVdGlsczo6dGlt ZW91dF9kZWZhdWx0KSk7Ciskbm9kZS0+YXBwZW5kX2NvbmYoJ3Bvc3RncmVzcWwuY29uZicsICdm c3luYyA9IG9mZicpOworJG5vZGUtPnN0YXJ0OworJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMn LCBxKENSRUFURSBFWFRFTlNJT04gYW1jaGVjaykpOworJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdy ZXMnLCBxKENSRUFURSBUQUJMRSB0YmwoaSBpbnQgcHJpbWFyeSBrZXksCisJCQkJCQkJCWMxIG1v bmV5IGRlZmF1bHQgMCxjMiBtb25leSBkZWZhdWx0IDAsCisJCQkJCQkJCWMzIG1vbmV5IGRlZmF1 bHQgMCwgdXBkYXRlZF9hdCB0aW1lc3RhbXApKSk7Ciskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3Jl cycsIHEoQ1JFQVRFIElOREVYIGlkeCBPTiB0YmwoaSkpKTsKKworbXkgJGJ1aWxkZXIgPSBUZXN0 OjpNb3JlLT5idWlsZGVyOworJGJ1aWxkZXItPnVzZV9udW1iZXJzKDApOworJGJ1aWxkZXItPm5v X3BsYW4oKTsKKworbXkgJGNoaWxkICA9ICRidWlsZGVyLT5jaGlsZCgicGdfYmVuY2giKTsKKwor aWYoIWRlZmluZWQoJHBpZCA9IGZvcmsoKSkpIHsKKwkjIGZvcmsgcmV0dXJuZWQgdW5kZWYsIHNv IHVuc3VjY2Vzc2Z1bAorCWRpZSAiQ2Fubm90IGZvcmsgYSBjaGlsZDogJCEiOworfSBlbHNpZiAo JHBpZCA9PSAwKSB7CisKKwkkbm9kZS0+cGdiZW5jaCgKKwkJJy0tbm8tdmFjdXVtIC0tY2xpZW50 PTUgLS10cmFuc2FjdGlvbnM9MjUwMDAnLAorCQkwLAorCQlbcXJ7YWN0dWFsbHkgcHJvY2Vzc2Vk fV0sCisJCVtxcnteJH1dLAorCQknY29uY3VycmVudCBJTlNFUlRzLCBVUERBVEVTIGFuZCBSQycs CisJCXsKKwkJCScwMDJfcGdiZW5jaF9jb25jdXJyZW50X3RyYW5zYWN0aW9uX2luc2VydHMnID0+ IHEoCisJCQkJQkVHSU47CisJCQkJSU5TRVJUIElOVE8gdGJsIFZBTFVFUyhyYW5kb20oKSoxMDAw MCwwLDAsMCxub3coKSkKKwkJCQkJb24gY29uZmxpY3QoaSkgZG8gdXBkYXRlIHNldCB1cGRhdGVk X2F0ID0gbm93KCk7CisJCQkJSU5TRVJUIElOVE8gdGJsIFZBTFVFUyhyYW5kb20oKSoxMDAwMCww LDAsMCxub3coKSkKKwkJCQkJb24gY29uZmxpY3QoaSkgZG8gdXBkYXRlIHNldCB1cGRhdGVkX2F0 ID0gbm93KCk7CisJCQkJSU5TRVJUIElOVE8gdGJsIFZBTFVFUyhyYW5kb20oKSoxMDAwMCwwLDAs MCxub3coKSkKKwkJCQkJb24gY29uZmxpY3QoaSkgZG8gdXBkYXRlIHNldCB1cGRhdGVkX2F0ID0g bm93KCk7CisJCQkJSU5TRVJUIElOVE8gdGJsIFZBTFVFUyhyYW5kb20oKSoxMDAwMCwwLDAsMCxu b3coKSkKKwkJCQkJb24gY29uZmxpY3QoaSkgZG8gdXBkYXRlIHNldCB1cGRhdGVkX2F0ID0gbm93 KCk7CisKKwkJCQlJTlNFUlQgSU5UTyB0YmwgVkFMVUVTKHJhbmRvbSgpKjEwMDAwLDAsMCwwLG5v dygpKQorCQkJCQlvbiBjb25mbGljdChpKSBkbyB1cGRhdGUgc2V0IHVwZGF0ZWRfYXQgPSBub3co KTsKKwkJCQlDT01NSVQ7CisJCQkgICksCisJCQkjIEVuc3VyZSBzb21lIEhPVCB1cGRhdGVzIGhh cHBlbgorCQkJJzAwMl9wZ2JlbmNoX2NvbmN1cnJlbnRfdHJhbnNhY3Rpb25fdXBkYXRlcycgPT4g cSgKKwkJCQlCRUdJTjsKKwkJCQlJTlNFUlQgSU5UTyB0YmwgVkFMVUVTKHJhbmRvbSgpKjEwMDAs MCwwLDAsbm93KCkpCisJCQkJCW9uIGNvbmZsaWN0KGkpIGRvIHVwZGF0ZSBzZXQgdXBkYXRlZF9h dCA9IG5vdygpOworCQkJCUlOU0VSVCBJTlRPIHRibCBWQUxVRVMocmFuZG9tKCkqMTAwMCwwLDAs MCxub3coKSkKKwkJCQkJb24gY29uZmxpY3QoaSkgZG8gdXBkYXRlIHNldCB1cGRhdGVkX2F0ID0g bm93KCk7CisJCQkJSU5TRVJUIElOVE8gdGJsIFZBTFVFUyhyYW5kb20oKSoxMDAwLDAsMCwwLG5v dygpKQorCQkJCQlvbiBjb25mbGljdChpKSBkbyB1cGRhdGUgc2V0IHVwZGF0ZWRfYXQgPSBub3co KTsKKwkJCQlJTlNFUlQgSU5UTyB0YmwgVkFMVUVTKHJhbmRvbSgpKjEwMDAsMCwwLDAsbm93KCkp CisJCQkJCW9uIGNvbmZsaWN0KGkpIGRvIHVwZGF0ZSBzZXQgdXBkYXRlZF9hdCA9IG5vdygpOwor CisJCQkJSU5TRVJUIElOVE8gdGJsIFZBTFVFUyhyYW5kb20oKSoxMDAwLDAsMCwwLG5vdygpKQor CQkJCQlvbiBjb25mbGljdChpKSBkbyB1cGRhdGUgc2V0IHVwZGF0ZWRfYXQgPSBub3coKTsKKwkJ CQlDT01NSVQ7CisJCQkgICkKKwkJfSk7CisKKwlpZiAoJGNoaWxkLT5pc19wYXNzaW5nKCkpIHsK KwkJc2htd3JpdGUoJHNobWVtX2lkLCAiZG9uZSIsIDAsICRzaG1lbV9zaXplKSBvciBkaWUgIkNh bid0IHNobXdyaXRlOiAkISI7CisJfSBlbHNlIHsKKwkJc2htd3JpdGUoJHNobWVtX2lkLCAiZmFp bCIsIDAsICRzaG1lbV9zaXplKSBvciBkaWUgIkNhbid0IHNobXdyaXRlOiAkISI7CisJfQorCisJ c2xlZXAoMSk7Cit9IGVsc2UgeworCW15ICRwZ19iZW5jaF9mb3JrX2ZsYWc7CisJc2htcmVhZCgk c2htZW1faWQsICRwZ19iZW5jaF9mb3JrX2ZsYWcsIDAsICRzaG1lbV9zaXplKSBvciBkaWUgIkNh bid0IHNobXJlYWQ6ICQhIjsKKworCXN1YnRlc3QgJ3JlaW5kZXggcnVuIHN1YnRlc3QnID0+IHN1 YiB7CisJCWlzKCRwZ19iZW5jaF9mb3JrX2ZsYWcsICJ3YWl0IiwgInBnX2JlbmNoX2ZvcmtfZmxh ZyBpcyBjb3JyZWN0Iik7CisKKwkJbXkgJXBzcWwgPSAoc3RkaW4gPT4gJycsIHN0ZG91dCA9PiAn Jywgc3RkZXJyID0+ICcnKTsKKwkJJHBzcWx7cnVufSA9IElQQzo6UnVuOjpzdGFydCgKKwkJCVsg J3BzcWwnLCAnLVhBJywgJy1mJywgJy0nLCAnLWQnLCAkbm9kZS0+Y29ubnN0cigncG9zdGdyZXMn KSBdLAorCQkJJzwnLAorCQkJXCRwc3Fse3N0ZGlufSwKKwkJCSc+JywKKwkJCVwkcHNxbHtzdGRv dXR9LAorCQkJJzI+JywKKwkJCVwkcHNxbHtzdGRlcnJ9LAorCQkJJHBzcWxfdGltZW91dCk7CisK KwkJbXkgKCRyZXN1bHQsICRzdGRvdXQsICRzdGRlcnIpOworCQl3aGlsZSAoMSkKKwkJeworCisJ CQkoJHJlc3VsdCwgJHN0ZG91dCwgJHN0ZGVycikgPSAkbm9kZS0+cHNxbCgncG9zdGdyZXMnLCBx KFJFSU5ERVggSU5ERVggQ09OQ1VSUkVOVExZIGlkeDspKTsKKwkJCWlzKCRyZXN1bHQsICcwJywg J1JFSU5ERVggaXMgY29ycmVjdCcpOworCisJCQkoJHJlc3VsdCwgJHN0ZG91dCwgJHN0ZGVycikg PSAkbm9kZS0+cHNxbCgncG9zdGdyZXMnLCBxKFNFTEVDVCBidF9pbmRleF9wYXJlbnRfY2hlY2so J2lkeCcsIHRydWUsIHRydWUpOykpOworCQkJaXMoJHJlc3VsdCwgJzAnLCAnYnRfaW5kZXhfY2hl Y2sgaXMgY29ycmVjdCcpOworIAkJCWlmICgkcmVzdWx0KQorIAkJCXsKKwkJCQlkaWFnKCRzdGRl cnIpOworIAkJCX0KKworCQkJc2htcmVhZCgkc2htZW1faWQsICRwZ19iZW5jaF9mb3JrX2ZsYWcs IDAsICRzaG1lbV9zaXplKSBvciBkaWUgIkNhbid0IHNobXJlYWQ6ICQhIjsKKwkJCWxhc3QgaWYg JHBnX2JlbmNoX2ZvcmtfZmxhZyBuZSAid2FpdCI7CisJCX0KKworCQkjIGV4cGxpY2l0bHkgc2h1 dCBkb3duIHBzcWwgaW5zdGFuY2VzIGdyYWNlZnVsbHkKKyAgICAgICAgJHBzcWx7c3RkaW59IC49 ICJcXHFcbiI7CisgICAgICAgICRwc3Fse3J1bn0tPmZpbmlzaDsKKworCQlpcygkcGdfYmVuY2hf Zm9ya19mbGFnLCAiZG9uZSIsICJwZ19iZW5jaF9mb3JrX2ZsYWcgaXMgY29ycmVjdCIpOworCX07 CisKKworCSRjaGlsZC0+ZmluYWxpemUoKTsKKwkkY2hpbGQtPnN1bW1hcnkoKTsKKwkkbm9kZS0+ c3RvcDsKKwlkb25lX3Rlc3RpbmcoKTsKK30KZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2NhdGFs b2cvaW5kZXguaCBiL3NyYy9pbmNsdWRlL2NhdGFsb2cvaW5kZXguaAppbmRleCAyZGVhOTZmNDdj Li5jYWM0MTNlNWViIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9jYXRhbG9nL2luZGV4LmgKKysr IGIvc3JjL2luY2x1ZGUvY2F0YWxvZy9pbmRleC5oCkBAIC0xNzUsNiArMTc1LDExIEBAIGV4dGVy biB2b2lkIFJlc3RvcmVSZWluZGV4U3RhdGUoY29uc3Qgdm9pZCAqcmVpbmRleHN0YXRlKTsKIAog ZXh0ZXJuIHZvaWQgSW5kZXhTZXRQYXJlbnRJbmRleChSZWxhdGlvbiBwYXJ0aXRpb25JZHgsIE9p ZCBwYXJlbnRPaWQpOwogCitleHRlcm4gdm9pZCBTYWZlSUNTdGF0ZVNobWVtSW5pdCh2b2lkKTsK Ky8vIFRPRE86IGJvdW5kIGJ5IHJlbGF0aW9uIG9yIGRhdGFiYXNlCitleHRlcm4gdm9pZCBVcGRh dGVOdW1TYWZlQ29uY3VycmVudGx5QnVpbHRJbmRleGVzKGJvb2wgaW5jcmVtZW50KTsKK2V4dGVy biBib29sIElzQW55U2FmZUluZGV4QnVpbGRzQ29uY3VycmVudGx5KHZvaWQpOworCiAKIC8qCiAg KiBpdGVtcHRyX2VuY29kZSAtIEVuY29kZSBJdGVtUG9pbnRlciBhcyBpbnQ2NC9pbnQ4CmRpZmYg LS1naXQgYS9zcmMvaW5jbHVkZS91dGlscy9yZWwuaCBiL3NyYy9pbmNsdWRlL3V0aWxzL3JlbC5o CmluZGV4IDg3MDAyMDQ5NTMuLmUzYzc4OTkyMDMgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3V0 aWxzL3JlbC5oCisrKyBiL3NyYy9pbmNsdWRlL3V0aWxzL3JlbC5oCkBAIC0xNTIsNiArMTUyLDcg QEAgdHlwZWRlZiBzdHJ1Y3QgUmVsYXRpb25EYXRhCiAJTGlzdAkgICAqcmRfaW5kZXhsaXN0Owkv KiBsaXN0IG9mIE9JRHMgb2YgaW5kZXhlcyBvbiByZWxhdGlvbiAqLwogCU9pZAkJCXJkX3BraW5k ZXg7CQkvKiBPSUQgb2YgKGRlZmVycmFibGU/KSBwcmltYXJ5IGtleSwgaWYgYW55ICovCiAJYm9v bAkJcmRfaXNwa2RlZmVycmFibGU7CS8qIGlzIHJkX3BraW5kZXggYSBkZWZlcnJhYmxlIFBLPyAq LworCWJvb2wJCXJkX3NhZmVpbmRleGNvbmN1cnJlbnRseWJ1aWxkaW5nOyAvKiBpcyBzYWZlIGNv bmN1cnJlbnQgaW5kZXggYnVpbGRpbmcgaW4gcHJvZ3Jlc3MgZm9yIHJlbGF0aW9uICovCiAJT2lk CQkJcmRfcmVwbGlkaW5kZXg7IC8qIE9JRCBvZiByZXBsaWNhIGlkZW50aXR5IGluZGV4LCBpZiBh bnkgKi8KIAogCS8qIGRhdGEgbWFuYWdlZCBieSBSZWxhdGlvbkdldFN0YXRFeHRMaXN0OiAqLwot LSAKMi4zNC4xCgo= --00000000000060f4ca061805069d--