Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtp (Exim 4.84_2) (envelope-from ) id 1eePji-00028R-97 for pgsql-hackers@arkaria.postgresql.org; Wed, 24 Jan 2018 18:25:26 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.84_2) (envelope-from ) id 1eePjh-0005Fp-Rp for pgsql-hackers@arkaria.postgresql.org; Wed, 24 Jan 2018 18:25:25 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA384:256) (Exim 4.84_2) (envelope-from ) id 1eePjh-0005Ff-Jo for pgsql-hackers@lists.postgresql.org; Wed, 24 Jan 2018 18:25:25 +0000 Received: from mail.thelabyrinth.net ([45.56.70.56]) by magus.postgresql.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA384:256) (Exim 4.89) (envelope-from ) id 1eePjd-0005zU-FF for pgsql-hackers@postgresql.org; Wed, 24 Jan 2018 18:25:25 +0000 Received: from Davids-iMac.local (unknown [173.169.74.224]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: dsteele) by mail.thelabyrinth.net (Postfix) with ESMTPSA id 5207B5468C; Wed, 24 Jan 2018 18:25:17 +0000 (UTC) Subject: Re: PATCH: Exclude unlogged tables from base backups To: Masahiko Sawada , Robert Haas Cc: Stephen Frost , Andres Freund , PostgreSQL-development References: <04791bab-cb04-ba43-e9c0-664a4c1ffb2c@pgmasters.net> <20171212225234.jqdwd4sp663l4znp@alap3.anarazel.de> <5e428ad7-f37f-6479-aabf-2c8b9318fb79@pgmasters.net> <20171212230740.evr7rvkzz5bztdg6@alap3.anarazel.de> <20171213014804.GH4628@tamriel.snowman.net> From: David Steele Message-ID: Date: Wed, 24 Jan 2018 13:25:16 -0500 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:52.0) Gecko/20100101 Thunderbird/52.5.2 MIME-Version: 1.0 In-Reply-To: Content-Type: multipart/mixed; boundary="------------BAFE0599E2AF18F83F079025" Content-Language: en-US List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Precedence: bulk This is a multi-part message in MIME format. --------------BAFE0599E2AF18F83F079025 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 7bit Hi Masahiko, Thanks for the review! On 1/22/18 3:14 AM, Masahiko Sawada wrote: > On Thu, Dec 14, 2017 at 11:58 PM, Robert Haas wrote: >> >> We would also have a problem if the missing file caused something in >> recovery to croak on the grounds that the file was expected to be >> there, but I don't think anything works that way; I think we just >> assume missing files are an expected failure mode and silently do >> nothing if asked to remove them. > > I also couldn't see a problem in this approach. > > Here is the first review comments. > > + unloggedDelim = strrchr(path, '/'); > > I think it doesn't work fine on windows. How about using > last_dir_separator() instead? I think this function is OK on Windows -- we use it quite a bit. However, last_dir_separator() is clearer so I have changed it. > ---- > + * Find all unlogged relations in the specified directory and return > their OIDs. > > What the ResetUnloggedrelationsHash() actually returns is a hash > table. The comment of this function seems not appropriate. Fixed. > + /* Part of path that contains the parent directory. */ > + int parentPathLen = unloggedDelim - path; > + > + /* > + * Build the unlogged relation hash if the parent path is either > + * $PGDATA/base or a tablespace version path. > + */ > + if (strncmp(path, "./base", parentPathLen) == 0 || > + (parentPathLen >= > (sizeof(TABLESPACE_VERSION_DIRECTORY) - 1) && > + strncmp(unloggedDelim - > (sizeof(TABLESPACE_VERSION_DIRECTORY) - 1), > + TABLESPACE_VERSION_DIRECTORY, > + > sizeof(TABLESPACE_VERSION_DIRECTORY) - 1) == 0)) > + unloggedHash = ResetUnloggedRelationsHash(path); > + } > > How about using get_parent_directory() to get parent directory name? get_parent_directory() munges the string that is passed to it which I was trying to avoid (we'd need a copy) - and I don't think it makes the rest of the logic any simpler without constructing yet another string to hold the tablespace path. I know performance isn't the most important thing here, so if the argument is for clarity perhaps it makes sense. Otherwise I don't know if it's worth it. > Also, I think it's better to destroy the unloggedHash after use. Whoops! Fixed. > + /* Exclude all forks for unlogged tables except the > init fork. */ > + if (unloggedHash && ResetUnloggedRelationsMatch( > + unloggedHash, de->d_name) == unloggedOther) > + { > + elog(DEBUG2, "unlogged relation file \"%s\" > excluded from backup", > + de->d_name); > + continue; > + } > > I think it's better to log this debug message at DEBUG2 level for > consistency with other messages. I think you mean DEBUG1? It's already at DEBUG2. I considered using DEBUG1 but decided against it. The other exclusions will produce a limited amount of output because there are only a few of them. In the case of unlogged tables there could be any number of exclusions and I thought that was too noisy for DEBUG1. > + ok(!-f "$tempdir/tbackup/tblspc1/$tblspc1UnloggedBackupPath", > + 'unlogged imain fork not in tablespace backup'); > > s/imain/main/ Fixed. > If a new unlogged relation is created after constructed the > unloggedHash before sending file, we cannot exclude such relation. It > would not be problem if the taking backup is not long because the new > unlogged relation unlikely becomes so large. However, if takeing a > backup takes a long time, we could include large main fork in the > backup. This is a good point. It's per database directory which makes it a little better, but maybe not by much. Three options here: 1) Leave it as is knowing that unlogged relations created during the backup may be copied and document it that way. 2) Construct a list for SendDir() to work against so the gap between creating that and creating the unlogged hash is as small as possible. The downside here is that the list may be very large and take up a lot of memory. 3) Check each file that looks like a relation in the loop to see if it has an init fork. This might affect performance since an opendir/readdir loop would be required for every relation. Personally, I'm in favor of #1, at least for the time being. I've updated the docs as indicated in case you and Adam agree. New patches attached. Thanks! -- -David david@pgmasters.net --------------BAFE0599E2AF18F83F079025 Content-Type: text/plain; charset=UTF-8; x-mac-type="0"; x-mac-creator="0"; name="exclude-unlogged-v2-01.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="exclude-unlogged-v2-01.patch" ZGlmZiAtLWdpdCBhL3NyYy90ZXN0L3JlY292ZXJ5L3QvMDE0X3VubG9nZ2VkX3JlaW5pdC5w bCBiL3NyYy90ZXN0L3JlY292ZXJ5L3QvMDE0X3VubG9nZ2VkX3JlaW5pdC5wbApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwLi5hYzJlMjUxMTU4Ci0tLSAvZGV2L251 bGwKKysrIGIvc3JjL3Rlc3QvcmVjb3ZlcnkvdC8wMTRfdW5sb2dnZWRfcmVpbml0LnBsCkBA IC0wLDAgKzEsMTE3IEBACisjIFRlc3RzIHRoYXQgdW5sb2dnZWQgdGFibGVzIGFyZSBwcm9w ZXJseSByZWluaXRpYWxpemVkIGFmdGVyIGEgY3Jhc2guCisjCisjIFRoZSBiZWhhdmlvciBz aG91bGQgYmUgdGhlIHNhbWUgd2hlbiByZXN0b3JpbmcgZnJvbSBhIGJhY2t1cCBidXQgdGhh dCBpcyBub3QKKyMgdGVzdGVkIGhlcmUgKHlldCkuCit1c2Ugc3RyaWN0OwordXNlIHdhcm5p bmdzOwordXNlIFBvc3RncmVzTm9kZTsKK3VzZSBUZXN0TGliOwordXNlIFRlc3Q6Ok1vcmUg dGVzdHMgPT4gMTY7CisKKyMgSW5pdGlhbGl6ZSBub2RlIHdpdGhvdXQgcmVwbGljYXRpb24g c2V0dGluZ3MKK215ICRub2RlID0gZ2V0X25ld19ub2RlKCdtYWluJyk7CisKKyRub2RlLT5p bml0OworJG5vZGUtPnN0YXJ0OworbXkgJHBnZGF0YSA9ICRub2RlLT5kYXRhX2RpcjsKKwor IyBDcmVhdGUgYW4gdW5sb2dnZWQgdGFibGUgdG8gdGVzdCB0aGF0IGZvcmtzIG90aGVyIHRo YW4gaW5pdCBhcmUgbm90IGNvcGllZAorJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLCAn Q1JFQVRFIFVOTE9HR0VEIFRBQkxFIGJhc2VfdW5sb2dnZWQgKGlkIGludCknKTsKKworbXkg JGJhc2VVbmxvZ2dlZFBhdGggPSAkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsCisJcXtz ZWxlY3QgcGdfcmVsYXRpb25fZmlsZXBhdGgoJ2Jhc2VfdW5sb2dnZWQnKX0pOworCisjIE1h a2Ugc3VyZSBtYWluIGFuZCBpbml0IGZvcmtzIGV4aXN0CitvaygtZiAiJHBnZGF0YS8ke2Jh c2VVbmxvZ2dlZFBhdGh9X2luaXQiLCAnaW5pdCBmb3JrIGluIGJhc2UnKTsKK29rKC1mICIk cGdkYXRhLyRiYXNlVW5sb2dnZWRQYXRoIiwgJ21haW4gZm9yayBpbiBiYXNlJyk7CisKKyMg VGhlIGZvbGxvd2luZyB0ZXN0cyB0ZXN0IHN5bWxpbmtzLiBXaW5kb3dzIGRvZXNuJ3QgaGF2 ZSBzeW1saW5rcywgc28KKyMgc2tpcCBvbiBXaW5kb3dzLgorbXkgJHRhYmxlc3BhY2VEaXIg PSB1bmRlZjsKK215ICR0czFVbmxvZ2dlZFBhdGggPSB1bmRlZjsKKworU0tJUDoKK3sKKwlz a2lwICJzeW1saW5rcyBub3Qgc3VwcG9ydGVkIG9uIFdpbmRvd3MiLCAyIGlmICgkd2luZG93 c19vcyk7CisKKwkjIENyZWF0ZSB1bmxvZ2dlZCB0YWJsZXMgaW4gYSB0YWJsZXNwYWNlCisJ JHRhYmxlc3BhY2VEaXIgPSBUZXN0TGliOjp0ZW1wZGlyIC4gIi90czEiOworCisJbWtkaXIo JHRhYmxlc3BhY2VEaXIpCisJCW9yIGRpZSAidW5hYmxlIHRvIG1rZGlyIFwiJHRhYmxlc3Bh Y2VEaXJcIiI7CisKKwkkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsCisJCSJDUkVBVEUg VEFCTEVTUEFDRSB0czEgTE9DQVRJT04gJyR0YWJsZXNwYWNlRGlyJyIpOworCSRub2RlLT5z YWZlX3BzcWwoJ3Bvc3RncmVzJywKKwkJJ0NSRUFURSBVTkxPR0dFRCBUQUJMRSB0czFfdW5s b2dnZWQgKGlkIGludCkgVEFCTEVTUEFDRSB0czEnKTsKKworCQkkdHMxVW5sb2dnZWRQYXRo ID0gJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLAorCQlxe3NlbGVjdCBwZ19yZWxhdGlv bl9maWxlcGF0aCgndHMxX3VubG9nZ2VkJyl9KTsKKworCSMgTWFrZSBzdXJlIG1haW4gYW5k IGluaXQgZm9ya3MgZXhpc3QKKwlvaygtZiAiJHBnZGF0YS8ke3RzMVVubG9nZ2VkUGF0aH1f aW5pdCIsICdpbml0IGZvcmsgaW4gdGFibGVzcGFjZScpOworCW9rKC1mICIkcGdkYXRhLyR0 czFVbmxvZ2dlZFBhdGgiLCAnbWFpbiBmb3JrIGluIHRhYmxlc3BhY2UnKTsKK30KKworIyBD cmFzaCB0aGUgcG9zdG1hc3RlcgorJG5vZGUtPnN0b3AoJ2ltbWVkaWF0ZScpOworCisjIFdy aXRlIGZvcmtzIHRvIHRlc3QgdGhhdCB0aGV5IGFyZSByZW1vdmVkIGR1cmluZyByZWNvdmVy eQorJG5vZGUtPmNvbW1hbmRfb2soWyd0b3VjaCcsICIkcGdkYXRhLyR7YmFzZVVubG9nZ2Vk UGF0aH1fdm0iXSwKKwkndG91Y2ggdm0gZm9yayBpbiBiYXNlJyk7Ciskbm9kZS0+Y29tbWFu ZF9vayhbJ3RvdWNoJywgIiRwZ2RhdGEvJHtiYXNlVW5sb2dnZWRQYXRofV9mc20iXSwKKwkn dG91Y2ggZnNtIGZvcmsgaW4gYmFzZScpOworCisjIFJlbW92ZSBtYWluIGZvcmsgdG8gdGVz dCB0aGF0IGl0IGlzIHJlY29waWVkIGZyb20gaW5pdAordW5saW5rKCIkcGdkYXRhLyR7YmFz ZVVubG9nZ2VkUGF0aH0iKQorCW9yIGRpZSAidW5hYmxlIHRvIHJlbW92ZSBcIiR7YmFzZVVu bG9nZ2VkUGF0aH1cIiI7CisKKyMgVGhlIGZvbGxvd2luZyB0ZXN0cyB0ZXN0IHN5bWxpbmtz LiBXaW5kb3dzIGRvZXNuJ3QgaGF2ZSBzeW1saW5rcywgc28KKyMgc2tpcCBvbiBXaW5kb3dz LgorU0tJUDoKK3sKKwlza2lwICJzeW1saW5rcyBub3Qgc3VwcG9ydGVkIG9uIFdpbmRvd3Mi LCAyIGlmICgkd2luZG93c19vcyk7CisKKwkjIFdyaXRlIGZvcmtzIHRvIHRlc3QgdGhhdCB0 aGV5IGFyZSByZW1vdmVkIGJ5IHJlY292ZXJ5CisJJG5vZGUtPmNvbW1hbmRfb2soWyd0b3Vj aCcsICIkcGdkYXRhLyR7dHMxVW5sb2dnZWRQYXRofV92bSJdLAorCQkndG91Y2ggdm0gZm9y ayBpbiB0YWJsZXNwYWNlJyk7CisJJG5vZGUtPmNvbW1hbmRfb2soWyd0b3VjaCcsICIkcGdk YXRhLyR7dHMxVW5sb2dnZWRQYXRofV9mc20iXSwKKwkJJ3RvdWNoIGZzbSBmb3JrIGluIHRh Ymxlc3BhY2UnKTsKKworCSMgUmVtb3ZlIG1haW4gZm9yayB0byB0ZXN0IHRoYXQgaXQgaXMg cmVjb3BpZWQgZnJvbSBpbml0CisJdW5saW5rKCIkcGdkYXRhLyR7dHMxVW5sb2dnZWRQYXRo fSIpCisJCW9yIGRpZSAidW5hYmxlIHRvIHJlbW92ZSBcIiR7dHMxVW5sb2dnZWRQYXRofVwi IjsKK30KKworIyBTdGFydCB0aGUgcG9zdG1hc3RlcgorJG5vZGUtPnN0YXJ0OworCisjIENo ZWNrIHVubG9nZ2VkIHRhYmxlIGluIGJhc2UKK29rKC1mICIkcGdkYXRhLyR7YmFzZVVubG9n Z2VkUGF0aH1faW5pdCIsICdpbml0IGZvcmsgaW4gYmFzZScpOworb2soLWYgIiRwZ2RhdGEv JGJhc2VVbmxvZ2dlZFBhdGgiLCAnbWFpbiBmb3JrIGluIGJhc2UnKTsKK29rKCEtZiAiJHBn ZGF0YS8ke2Jhc2VVbmxvZ2dlZFBhdGh9X3ZtIiwgJ3ZtIGZvcmsgbm90IGluIGJhc2UnKTsK K29rKCEtZiAiJHBnZGF0YS8ke2Jhc2VVbmxvZ2dlZFBhdGh9X2ZzbSIsICdmc20gZm9yayBu b3QgaW4gYmFzZScpOworCisjIERyb3AgdW5sb2dnZWQgdGFibGUKKyRub2RlLT5zYWZlX3Bz cWwoJ3Bvc3RncmVzJywgJ0RST1AgVEFCTEUgYmFzZV91bmxvZ2dlZCcpOworCisjIFRoZSBm b2xsb3dpbmcgdGVzdHMgdGVzdCBzeW1saW5rcy4gV2luZG93cyBkb2Vzbid0IGhhdmUgc3lt bGlua3MsIHNvCisjIHNraXAgb24gV2luZG93cy4KK1NLSVA6Cit7CisJc2tpcCAic3ltbGlu a3Mgbm90IHN1cHBvcnRlZCBvbiBXaW5kb3dzIiwgNCBpZiAoJHdpbmRvd3Nfb3MpOworCisJ IyBDaGVjayB1bmxvZ2dlZCB0YWJsZSBpbiB0YWJsZXNwYWNlCisJb2soLWYgIiRwZ2RhdGEv JHt0czFVbmxvZ2dlZFBhdGh9X2luaXQiLCAnaW5pdCBmb3JrIGluIHRhYmxlc3BhY2UnKTsK KwlvaygtZiAiJHBnZGF0YS8kdHMxVW5sb2dnZWRQYXRoIiwgJ21haW4gZm9yayBpbiB0YWJs ZXNwYWNlJyk7CisJb2soIS1mICIkcGdkYXRhLyR7dHMxVW5sb2dnZWRQYXRofV92bSIsICd2 bSBmb3JrIG5vdCBpbiB0YWJsZXNwYWNlJyk7CisJb2soIS1mICIkcGdkYXRhLyR7dHMxVW5s b2dnZWRQYXRofV9mc20iLCAnZnNtIGZvcmsgbm90IGluIHRhYmxlc3BhY2UnKTsKKworCSMg RHJvcCB1bmxvZ2dlZCB0YWJsZQorCSRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgJ0RS T1AgVEFCTEUgdHMxX3VubG9nZ2VkJyk7CisKKwkjIERyb3AgdGFibGVzcGFjZQorCSRub2Rl LT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgJ0RST1AgVEFCTEVTUEFDRSB0czEnKTsKKwlybWRp cigkdGFibGVzcGFjZURpcikKKwkJb3IgZGllICJ1bmFibGUgdG8gcm1kaXIgXCIkdGFibGVz cGFjZURpclwiIjsKK30K --------------BAFE0599E2AF18F83F079025 Content-Type: text/plain; charset=UTF-8; x-mac-type="0"; x-mac-creator="0"; name="exclude-unlogged-v2-02.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="exclude-unlogged-v2-02.patch" ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvZmlsZS9yZWluaXQuYyBiL3NyYy9i YWNrZW5kL3N0b3JhZ2UvZmlsZS9yZWluaXQuYwppbmRleCA5MjM2M2FlNmFkLi43M2EyNWZh M2U3IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9zdG9yYWdlL2ZpbGUvcmVpbml0LmMKKysr IGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9maWxlL3JlaW5pdC5jCkBAIC0yMSw3ICsyMSw2IEBA CiAjaW5jbHVkZSAic3RvcmFnZS9jb3B5ZGlyLmgiCiAjaW5jbHVkZSAic3RvcmFnZS9mZC5o IgogI2luY2x1ZGUgInN0b3JhZ2UvcmVpbml0LmgiCi0jaW5jbHVkZSAidXRpbHMvaHNlYXJj aC5oIgogI2luY2x1ZGUgInV0aWxzL21lbXV0aWxzLmgiCiAKIHN0YXRpYyB2b2lkIFJlc2V0 VW5sb2dnZWRSZWxhdGlvbnNJblRhYmxlc3BhY2VEaXIoY29uc3QgY2hhciAqdHNkaXJuYW1l LApAQCAtMTQ1LDYgKzE0NCwxMDAgQEAgUmVzZXRVbmxvZ2dlZFJlbGF0aW9uc0luVGFibGVz cGFjZURpcihjb25zdCBjaGFyICp0c2Rpcm5hbWUsIGludCBvcCkKIAlGcmVlRGlyKHRzX2Rp cik7CiB9CiAKKy8qCisgKiBGaW5kIGFsbCB1bmxvZ2dlZCByZWxhdGlvbnMgaW4gdGhlIHNw ZWNpZmllZCBkaXJlY3RvcnkgYW5kIHJldHVybiB0aGVpciBPSURzCisgKiBhcyBhIGhhc2gg dGFibGUuCisgKgorICogSXQncyBwb3NzaWJsZSB0aGF0IHNvbWVvbmUgY291bGQgY3JlYXRl IGEgdG9uIG9mIHVubG9nZ2VkIHJlbGF0aW9ucyBpbiB0aGUKKyAqIHNhbWUgZGF0YWJhc2Ug JiB0YWJsZXNwYWNlLCBzbyB3ZSdkIGJldHRlciB1c2UgYSBoYXNoIHRhYmxlIHJhdGhlciB0 aGFuIGFuCisgKiBhcnJheSBvciBsaW5rZWQgbGlzdCB0byBrZWVwIHRyYWNrIG9mIHdoaWNo IGZpbGVzIG5lZWQgdG8gYmUgcmVzZXQuCisgKiBPdGhlcndpc2UsIHNlYXJjaCBvcGVyYXRp b25zIHdvdWxkIGJlIE8obl4yKS4KKyAqLworSFRBQiAqCitSZXNldFVubG9nZ2VkUmVsYXRp b25zSGFzaChjb25zdCBjaGFyICpkYnNwYWNlZGlybmFtZSkKK3sKKwlESVIgKmRic3BhY2Vf ZGlyOworCXN0cnVjdCBkaXJlbnQgKmRlOworCUhUQUIgKmhhc2ggPSBOVUxMOworCisJLyog U2NhbiB0aGUgZGlyZWN0b3J5LiAqLworCWRic3BhY2VfZGlyID0gQWxsb2NhdGVEaXIoZGJz cGFjZWRpcm5hbWUpOworCXdoaWxlICgoZGUgPSBSZWFkRGlyKGRic3BhY2VfZGlyLCBkYnNw YWNlZGlybmFtZSkpICE9IE5VTEwpCisJeworCQlGb3JrTnVtYmVyCWZvcmtOdW07CisJCWlu dAkJCW9pZGNoYXJzOworCQl1bmxvZ2dlZF9yZWxhdGlvbl9lbnRyeSBlbnQ7CisKKwkJLyog U2tpcCBhbnl0aGluZyB0aGF0IGRvZXNuJ3QgbG9vayBsaWtlIGEgcmVsYXRpb24gZGF0YSBm aWxlLiAqLworCQlpZiAoIXBhcnNlX2ZpbGVuYW1lX2Zvcl9ub250ZW1wX3JlbGF0aW9uKGRl LT5kX25hbWUsICZvaWRjaGFycywKKwkJCQkJCQkJCQkJCSAmZm9ya051bSkpCisJCQljb250 aW51ZTsKKworCQkvKiBBbHNvIHNraXAgaXQgdW5sZXNzIHRoaXMgaXMgdGhlIGluaXQgZm9y ay4gKi8KKwkJaWYgKGZvcmtOdW0gIT0gSU5JVF9GT1JLTlVNKQorCQkJY29udGludWU7CisK KwkJLyogQ3JlYXRlIHRoZSBoYXNoIHRhYmxlIGlmIGl0IGhhcyBub3QgYmVlbiBjcmVhdGVk IGFscmVhZHkuICovCisJCWlmICghaGFzaCkKKwkJeworCQkJSEFTSENUTCBjdGw7CisKKwkJ CW1lbXNldCgmY3RsLCAwLCBzaXplb2YoY3RsKSk7CisJCQljdGwua2V5c2l6ZSA9IHNpemVv Zih1bmxvZ2dlZF9yZWxhdGlvbl9lbnRyeSk7CisJCQljdGwuZW50cnlzaXplID0gc2l6ZW9m KHVubG9nZ2VkX3JlbGF0aW9uX2VudHJ5KTsKKwkJCWhhc2ggPSBoYXNoX2NyZWF0ZSgidW5s b2dnZWQgaGFzaCIsIDMyLCAmY3RsLCBIQVNIX0VMRU0pOworCQl9CisKKwkJLyoKKwkJICog UHV0IHRoZSBPSUQgcG9ydGlvbiBvZiB0aGUgbmFtZSBpbnRvIHRoZSBoYXNoIHRhYmxlLCBp ZiBpdAorCQkgKiBpc24ndCBhbHJlYWR5LgorCQkgKi8KKwkJbWVtc2V0KGVudC5vaWQsIDAs IHNpemVvZihlbnQub2lkKSk7CisJCW1lbWNweShlbnQub2lkLCBkZS0+ZF9uYW1lLCBvaWRj aGFycyk7CisJCWhhc2hfc2VhcmNoKGhhc2gsICZlbnQsIEhBU0hfRU5URVIsIE5VTEwpOwor CX0KKworCS8qIERvbmUgd2l0aCB0aGUgZmlyc3QgcGFzcy4gKi8KKwlGcmVlRGlyKGRic3Bh Y2VfZGlyKTsKKworCXJldHVybiBoYXNoOworfQorCisvKgorICogRGV0ZXJtaW5lIHdoZXRo ZXIgdGhlIHNwZWNpZmllZCBmaWxlIGlzIGFuIHVubG9nZ2VkIHJlbGF0aW9uIGZvcmsuCisg KgorICogSWYgbm90IGFuIHVubG9nZ2VkIHJlbGF0aW9uIHRoZW4gcmV0dXJuIG5vdFVubG9n Z2VkLCBvdGhlcndpc2UgcmV0dXJuCisgKiB1bmxvZ2dlZEluaXQgaWYgYW4gdW5sb2dnZWQg aW5pdCBmb3JrIGFuZCB1bmxvZ2dlZE90aGVyIGlmIGFueSBvdGhlciB1bmxvZ2dlZAorICog Zm9yay4KKyAqLworVW5sb2dnZWRSZWxhdGlvbkZvcmsKK1Jlc2V0VW5sb2dnZWRSZWxhdGlv bnNNYXRjaChIVEFCICpoYXNoLCBjb25zdCBjaGFyICpmaWxlKQoreworCUZvcmtOdW1iZXIJ Zm9ya051bTsKKwlpbnQJCQlvaWRjaGFyczsKKwlib29sIAkJZm91bmQ7CisJdW5sb2dnZWRf cmVsYXRpb25fZW50cnkgZW50OworCisJLyogSWYgaXQncyBub3QgYSByZWxhdGlvbiB0aGVu IGl0J3Mgbm90IHVubG9nZ2VkLiAqLworCWlmICghcGFyc2VfZmlsZW5hbWVfZm9yX25vbnRl bXBfcmVsYXRpb24oZmlsZSwgJm9pZGNoYXJzLCAmZm9ya051bSkpCisJCXJldHVybiBub3RV bmxvZ2dlZDsKKworCS8qIEFuIHVubG9nZ2VkIGluaXQgZm9yay4gKi8KKwlpZiAoZm9ya051 bSA9PSBJTklUX0ZPUktOVU0pCisJCXJldHVybiB1bmxvZ2dlZEluaXQ7CisKKwkvKiBTZWUg d2hldGhlciB0aGUgT0lEIHBvcnRpb24gb2YgdGhlIG5hbWUgc2hvd3MgdXAgaW4gdGhlIGhh c2ggdGFibGUuICovCisJbWVtc2V0KGVudC5vaWQsIDAsIHNpemVvZihlbnQub2lkKSk7CisJ bWVtY3B5KGVudC5vaWQsIGZpbGUsIG9pZGNoYXJzKTsKKwloYXNoX3NlYXJjaChoYXNoLCAm ZW50LCBIQVNIX0ZJTkQsICZmb3VuZCk7CisKKwkvKiBJZiBmb3VuZCB0aGlzIGlzIGFub3Ro ZXIgZm9yayBvZiBhbiB1bmxvZ2dlZCB0YWJsZSAoYnV0IG5vdCBpbml0KS4gKi8KKwlpZiAo Zm91bmQpCisJCXJldHVybiB1bmxvZ2dlZE90aGVyOworCisJcmV0dXJuIG5vdFVubG9nZ2Vk OworfQorCiAvKgogICogUHJvY2VzcyBvbmUgcGVyLWRic3BhY2UgZGlyZWN0b3J5IGZvciBS ZXNldFVubG9nZ2VkUmVsYXRpb25zCiAgKi8KQEAgLTE2Niw1OCArMjU5LDEzIEBAIFJlc2V0 VW5sb2dnZWRSZWxhdGlvbnNJbkRic3BhY2VEaXIoY29uc3QgY2hhciAqZGJzcGFjZWRpcm5h bWUsIGludCBvcCkKIAlpZiAoKG9wICYgVU5MT0dHRURfUkVMQVRJT05fQ0xFQU5VUCkgIT0g MCkKIAl7CiAJCUhUQUIJICAgKmhhc2g7Ci0JCUhBU0hDVEwJCWN0bDsKLQotCQkvKgotCQkg KiBJdCdzIHBvc3NpYmxlIHRoYXQgc29tZW9uZSBjb3VsZCBjcmVhdGUgYSB0b24gb2YgdW5s b2dnZWQgcmVsYXRpb25zCi0JCSAqIGluIHRoZSBzYW1lIGRhdGFiYXNlICYgdGFibGVzcGFj ZSwgc28gd2UnZCBiZXR0ZXIgdXNlIGEgaGFzaCB0YWJsZQotCQkgKiByYXRoZXIgdGhhbiBh biBhcnJheSBvciBsaW5rZWQgbGlzdCB0byBrZWVwIHRyYWNrIG9mIHdoaWNoIGZpbGVzCi0J CSAqIG5lZWQgdG8gYmUgcmVzZXQuICBPdGhlcndpc2UsIHRoaXMgY2xlYW51cCBvcGVyYXRp b24gd291bGQgYmUKLQkJICogTyhuXjIpLgotCQkgKi8KLQkJbWVtc2V0KCZjdGwsIDAsIHNp emVvZihjdGwpKTsKLQkJY3RsLmtleXNpemUgPSBzaXplb2YodW5sb2dnZWRfcmVsYXRpb25f ZW50cnkpOwotCQljdGwuZW50cnlzaXplID0gc2l6ZW9mKHVubG9nZ2VkX3JlbGF0aW9uX2Vu dHJ5KTsKLQkJaGFzaCA9IGhhc2hfY3JlYXRlKCJ1bmxvZ2dlZCBoYXNoIiwgMzIsICZjdGws IEhBU0hfRUxFTSk7Ci0KLQkJLyogU2NhbiB0aGUgZGlyZWN0b3J5LiAqLwotCQlkYnNwYWNl X2RpciA9IEFsbG9jYXRlRGlyKGRic3BhY2VkaXJuYW1lKTsKLQkJd2hpbGUgKChkZSA9IFJl YWREaXIoZGJzcGFjZV9kaXIsIGRic3BhY2VkaXJuYW1lKSkgIT0gTlVMTCkKLQkJewotCQkJ Rm9ya051bWJlcglmb3JrTnVtOwotCQkJaW50CQkJb2lkY2hhcnM7Ci0JCQl1bmxvZ2dlZF9y ZWxhdGlvbl9lbnRyeSBlbnQ7Ci0KLQkJCS8qIFNraXAgYW55dGhpbmcgdGhhdCBkb2Vzbid0 IGxvb2sgbGlrZSBhIHJlbGF0aW9uIGRhdGEgZmlsZS4gKi8KLQkJCWlmICghcGFyc2VfZmls ZW5hbWVfZm9yX25vbnRlbXBfcmVsYXRpb24oZGUtPmRfbmFtZSwgJm9pZGNoYXJzLAotCQkJ CQkJCQkJCQkJCSAmZm9ya051bSkpCi0JCQkJY29udGludWU7Ci0KLQkJCS8qIEFsc28gc2tp cCBpdCB1bmxlc3MgdGhpcyBpcyB0aGUgaW5pdCBmb3JrLiAqLwotCQkJaWYgKGZvcmtOdW0g IT0gSU5JVF9GT1JLTlVNKQotCQkJCWNvbnRpbnVlOwogCi0JCQkvKgotCQkJICogUHV0IHRo ZSBPSUQgcG9ydGlvbiBvZiB0aGUgbmFtZSBpbnRvIHRoZSBoYXNoIHRhYmxlLCBpZiBpdAot CQkJICogaXNuJ3QgYWxyZWFkeS4KLQkJCSAqLwotCQkJbWVtc2V0KGVudC5vaWQsIDAsIHNp emVvZihlbnQub2lkKSk7Ci0JCQltZW1jcHkoZW50Lm9pZCwgZGUtPmRfbmFtZSwgb2lkY2hh cnMpOwotCQkJaGFzaF9zZWFyY2goaGFzaCwgJmVudCwgSEFTSF9FTlRFUiwgTlVMTCk7Ci0J CX0KLQotCQkvKiBEb25lIHdpdGggdGhlIGZpcnN0IHBhc3MuICovCi0JCUZyZWVEaXIoZGJz cGFjZV9kaXIpOworCQkvKiBCdWlsZCBhIGhhc2ggdGFibGUgb2YgYWxsIHVubG9nZ2VkIHJl bGF0aW9ucy4gKi8KKwkJaGFzaCA9IFJlc2V0VW5sb2dnZWRSZWxhdGlvbnNIYXNoKGRic3Bh Y2VkaXJuYW1lKTsKIAotCQkvKgotCQkgKiBJZiB3ZSBkaWRuJ3QgZmluZCBhbnkgaW5pdCBm b3JrcywgdGhlcmUncyBubyBwb2ludCBpbiBjb250aW51aW5nOwotCQkgKiB3ZSBjYW4gYmFp bCBvdXQgbm93LgotCQkgKi8KLQkJaWYgKGhhc2hfZ2V0X251bV9lbnRyaWVzKGhhc2gpID09 IDApCi0JCXsKLQkJCWhhc2hfZGVzdHJveShoYXNoKTsKKwkJLyogTm8gbmVlZCB0byBjb250 aW51ZSBpZiB0aGVyZSBhcmUgbm8gdW5sb2dnZWQgdGFibGVzLiAqLworCQlpZiAoIWhhc2gp CiAJCQlyZXR1cm47Ci0JCX0KIAogCQkvKgogCQkgKiBOb3csIG1ha2UgYSBzZWNvbmQgcGFz cyBhbmQgcmVtb3ZlIGFueXRoaW5nIHRoYXQgbWF0Y2hlcy4KQEAgLTIyNSwzMCArMjczLDkg QEAgUmVzZXRVbmxvZ2dlZFJlbGF0aW9uc0luRGJzcGFjZURpcihjb25zdCBjaGFyICpkYnNw YWNlZGlybmFtZSwgaW50IG9wKQogCQlkYnNwYWNlX2RpciA9IEFsbG9jYXRlRGlyKGRic3Bh Y2VkaXJuYW1lKTsKIAkJd2hpbGUgKChkZSA9IFJlYWREaXIoZGJzcGFjZV9kaXIsIGRic3Bh Y2VkaXJuYW1lKSkgIT0gTlVMTCkKIAkJewotCQkJRm9ya051bWJlcglmb3JrTnVtOwotCQkJ aW50CQkJb2lkY2hhcnM7Ci0JCQlib29sCQlmb3VuZDsKLQkJCXVubG9nZ2VkX3JlbGF0aW9u X2VudHJ5IGVudDsKLQotCQkJLyogU2tpcCBhbnl0aGluZyB0aGF0IGRvZXNuJ3QgbG9vayBs aWtlIGEgcmVsYXRpb24gZGF0YSBmaWxlLiAqLwotCQkJaWYgKCFwYXJzZV9maWxlbmFtZV9m b3Jfbm9udGVtcF9yZWxhdGlvbihkZS0+ZF9uYW1lLCAmb2lkY2hhcnMsCi0JCQkJCQkJCQkJ CQkJICZmb3JrTnVtKSkKLQkJCQljb250aW51ZTsKLQotCQkJLyogV2UgbmV2ZXIgcmVtb3Zl IHRoZSBpbml0IGZvcmsuICovCi0JCQlpZiAoZm9ya051bSA9PSBJTklUX0ZPUktOVU0pCi0J CQkJY29udGludWU7Ci0KLQkJCS8qCi0JCQkgKiBTZWUgd2hldGhlciB0aGUgT0lEIHBvcnRp b24gb2YgdGhlIG5hbWUgc2hvd3MgdXAgaW4gdGhlIGhhc2gKLQkJCSAqIHRhYmxlLgotCQkJ ICovCi0JCQltZW1zZXQoZW50Lm9pZCwgMCwgc2l6ZW9mKGVudC5vaWQpKTsKLQkJCW1lbWNw eShlbnQub2lkLCBkZS0+ZF9uYW1lLCBvaWRjaGFycyk7Ci0JCQloYXNoX3NlYXJjaChoYXNo LCAmZW50LCBIQVNIX0ZJTkQsICZmb3VuZCk7Ci0KLQkJCS8qIElmIHNvLCBudWtlIGl0ISAq LwotCQkJaWYgKGZvdW5kKQorCQkJLyogSWYgdGhpcyBpcyBhbiB1bmxvZ2dlZCByZWxhdGlv biBmb3JrIG90aGVyIHRoYW4gaW5pdCwgbnVrZSBpdCEgKi8KKwkJCWlmIChSZXNldFVubG9n Z2VkUmVsYXRpb25zTWF0Y2goCisJCQkJCWhhc2gsIGRlLT5kX25hbWUpID09IHVubG9nZ2Vk T3RoZXIpCiAJCQl7CiAJCQkJc25wcmludGYocm1fcGF0aCwgc2l6ZW9mKHJtX3BhdGgpLCAi JXMvJXMiLAogCQkJCQkJIGRic3BhY2VkaXJuYW1lLCBkZS0+ZF9uYW1lKTsKZGlmZiAtLWdp dCBhL3NyYy9pbmNsdWRlL3N0b3JhZ2UvcmVpbml0LmggYi9zcmMvaW5jbHVkZS9zdG9yYWdl L3JlaW5pdC5oCmluZGV4IGFkZGRhMmMwZWEuLmNkNDIyZTUxOWEgMTAwNjQ0Ci0tLSBhL3Ny Yy9pbmNsdWRlL3N0b3JhZ2UvcmVpbml0LmgKKysrIGIvc3JjL2luY2x1ZGUvc3RvcmFnZS9y ZWluaXQuaApAQCAtMTUsOSArMTUsMjQgQEAKICNpZm5kZWYgUkVJTklUX0gKICNkZWZpbmUg UkVJTklUX0gKIAorI2luY2x1ZGUgInV0aWxzL2hzZWFyY2guaCIKKwogZXh0ZXJuIHZvaWQg UmVzZXRVbmxvZ2dlZFJlbGF0aW9ucyhpbnQgb3ApOwogCiAjZGVmaW5lIFVOTE9HR0VEX1JF TEFUSU9OX0NMRUFOVVAJCTB4MDAwMQogI2RlZmluZSBVTkxPR0dFRF9SRUxBVElPTl9JTklU CQkJMHgwMDAyCiAKKy8qIFJldHVybiB2YWx1ZXMgZm9yIFJlc2V0VW5sb2dnZWRSZWxhdGlv bnNNYXRjaCgpLiAqLwordHlwZWRlZiBlbnVtCit7CisJbm90VW5sb2dnZWQsCQkJLyogTm90 IGEgcmVsYXRpb24gb3Igbm90IGFuIHVubG9nZ2VkIHJlbGF0aW9uLiAqLworCXVubG9nZ2Vk SW5pdCwJCQkvKiBBbiB1bmxvZ2dlZCByZWxhdGlvbiBpbml0IGZvcmsuICovCisJdW5sb2dn ZWRPdGhlcgkJCS8qIEFuIHVubG9nZ2VkIHJlbGF0aW9uIGZvcmsgb3RoZXIgdGhhbiBpbml0 LiAqLworfSBVbmxvZ2dlZFJlbGF0aW9uRm9yazsKKworLyogVXRpbGl0eSBmdW5jdGlvbnMg Zm9yIGlkZW50aWZ5aW5nIHVubG9nZ2VkIHRhYmxlIGZvcmtzLiAqLworZXh0ZXJuIEhUQUIg KlJlc2V0VW5sb2dnZWRSZWxhdGlvbnNIYXNoKGNvbnN0IGNoYXIgKmRic3BhY2VkaXJuYW1l KTsKK2V4dGVybiBVbmxvZ2dlZFJlbGF0aW9uRm9yayBSZXNldFVubG9nZ2VkUmVsYXRpb25z TWF0Y2goCisJSFRBQiAqdW5sb2dnZWRIYXNoLCBjb25zdCBjaGFyICpmaWxlTmFtZSk7CisK ICNlbmRpZgkJCQkJCQkvKiBSRUlOSVRfSCAqLwo= --------------BAFE0599E2AF18F83F079025 Content-Type: text/plain; charset=UTF-8; x-mac-type="0"; x-mac-creator="0"; name="exclude-unlogged-v2-03.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="exclude-unlogged-v2-03.patch" ZGlmZiAtLWdpdCBhL2RvYy9zcmMvc2dtbC9wcm90b2NvbC5zZ21sIGIvZG9jL3NyYy9zZ21s L3Byb3RvY29sLnNnbWwKaW5kZXggNGM1ZWQxZTZkNi4uM2ZlYzQ5MWJiZSAxMDA2NDQKLS0t IGEvZG9jL3NyYy9zZ21sL3Byb3RvY29sLnNnbWwKKysrIGIvZG9jL3NyYy9zZ21sL3Byb3Rv Y29sLnNnbWwKQEAgLTI1NTIsNiArMjU1MiwxNCBAQCBUaGUgY29tbWFuZHMgYWNjZXB0ZWQg aW4gd2Fsc2VuZGVyIG1vZGUgYXJlOgogICAgICAgICAgd2l0aCA8ZmlsZW5hbWU+cGdzcWxf dG1wPC9maWxlbmFtZT4uCiAgICAgICAgIDwvcGFyYT4KICAgICAgICA8L2xpc3RpdGVtPgor ICAgICAgIDxsaXN0aXRlbT4KKyAgICAgICAgPHBhcmE+CisgICAgICAgICBVbmxvZ2dlZCBy ZWxhdGlvbnMsIGV4Y2VwdCBmb3IgdGhlIGluaXQgZm9yayB3aGljaCBpcyByZXF1aXJlZCB0 bworICAgICAgICAgcmVjcmVhdGUgdGhlIChlbXB0eSkgdW5sb2dnZWQgcmVsYXRpb24gb24g cmVjb3ZlcnkuICBVbmxvZ2dlZCB0YWJsZXMKKyAgICAgICAgIGNyZWF0ZWQgZHVyaW5nIGEg YmFja3VwIG1heSBiZSBjb3BpZWQsIGJ1dCB3aWxsIGJlIGV4Y2x1ZGVkIGZyb20gdGhlCisg ICAgICAgICBuZXh0IGJhY2t1cC4KKyAgICAgICAgPC9wYXJhPgorICAgICAgIDwvbGlzdGl0 ZW0+CiAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICA8cGFyYT4KICAgICAgICAgIDxmaWxl bmFtZT5wZ193YWw8L2ZpbGVuYW1lPiwgaW5jbHVkaW5nIHN1YmRpcmVjdG9yaWVzLiBJZiB0 aGUgYmFja3VwIGlzIHJ1bgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24v YmFzZWJhY2t1cC5jIGIvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vYmFzZWJhY2t1cC5jCmlu ZGV4IGRkN2FkNjQ4NjIuLjFhNWM5MWRlMTcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3Jl cGxpY2F0aW9uL2Jhc2ViYWNrdXAuYworKysgYi9zcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9i YXNlYmFja3VwLmMKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNsdWRlICJub2Rlcy9wZ19saXN0 LmgiCiAjaW5jbHVkZSAicGd0YXIuaCIKICNpbmNsdWRlICJwZ3N0YXQuaCIKKyNpbmNsdWRl ICJwb3J0LmgiCiAjaW5jbHVkZSAicG9zdG1hc3Rlci9zeXNsb2dnZXIuaCIKICNpbmNsdWRl ICJyZXBsaWNhdGlvbi9iYXNlYmFja3VwLmgiCiAjaW5jbHVkZSAicmVwbGljYXRpb24vd2Fs c2VuZGVyLmgiCkBAIC0zMyw2ICszNCw3IEBACiAjaW5jbHVkZSAic3RvcmFnZS9kc21faW1w bC5oIgogI2luY2x1ZGUgInN0b3JhZ2UvZmQuaCIKICNpbmNsdWRlICJzdG9yYWdlL2lwYy5o IgorI2luY2x1ZGUgInN0b3JhZ2UvcmVpbml0LmgiCiAjaW5jbHVkZSAidXRpbHMvYnVpbHRp bnMuaCIKICNpbmNsdWRlICJ1dGlscy9lbG9nLmgiCiAjaW5jbHVkZSAidXRpbHMvcHNfc3Rh dHVzLmgiCkBAIC05NTksNiArOTYxLDM2IEBAIHNlbmREaXIoY29uc3QgY2hhciAqcGF0aCwg aW50IGJhc2VwYXRobGVuLCBib29sIHNpemVvbmx5LCBMaXN0ICp0YWJsZXNwYWNlcywKIAlj aGFyCQlwYXRoYnVmW01BWFBHUEFUSCAqIDJdOwogCXN0cnVjdCBzdGF0IHN0YXRidWY7CiAJ aW50NjQJCXNpemUgPSAwOworCUhUQUIgCQkqdW5sb2dnZWRIYXNoID0gTlVMTDsJLyogVW5s b2dnZWQgdGFibGVzIGluIHRoaXMgcGF0aC4gKi8KKwljb25zdCBjaGFyIAkqdW5sb2dnZWRE ZWxpbTsJCQkvKiBTcGxpdCB0aGlzIHBhdGggZnJvbSBwYXJlbnQgcGF0aC4gKi8KKworCS8q CisJICogRmluZCBhbnkgdW5sb2dnZWQgcmVsYXRpb25zIGluIHRoaXMgcGF0aCBhbmQgc3Rv cmUgdGhlbSBpbiBhIGhhc2guIEFsbAorCSAqIHVubG9nZ2VkIHJlbGF0aW9uIGZvcmtzIGV4 Y2VwdCBpbml0IHdpbGwgYmUgZXhjbHVkZWQgZnJvbSB0aGUgYmFja3VwLgorCSAqCisJICog U3RhcnQgYnkgZmluZGluZyB0aGUgbG9jYXRpb24gb2YgdGhlIGRlbGltaXRlciBiZXR3ZWVu IHRoZSBwYXJlbnQKKwkgKiBwYXRoIGFuZCB0aGUgY3VycmVudCBwYXRoLgorCSAqLworCXVu bG9nZ2VkRGVsaW0gPSBsYXN0X2Rpcl9zZXBhcmF0b3IocGF0aCk7CisKKwkvKiBEb2VzIHRo aXMgcGF0aCBsb29rIGxpa2UgYSBkYXRhYmFzZSBwYXRoIChpLmUuIGFsbCBkaWdpdHMpPyAq LworCWlmICh1bmxvZ2dlZERlbGltICE9IE5VTEwgJiYKKwkJc3Ryc3BuKHVubG9nZ2VkRGVs aW0gKyAxLCAiMDEyMzQ1Njc4OSIpID09IHN0cmxlbih1bmxvZ2dlZERlbGltICsgMSkpCisJ eworCQkvKiBQYXJ0IG9mIHBhdGggdGhhdCBjb250YWlucyB0aGUgcGFyZW50IGRpcmVjdG9y eS4gKi8KKwkJaW50IHBhcmVudFBhdGhMZW4gPSB1bmxvZ2dlZERlbGltIC0gcGF0aDsKKwor CQkvKgorCQkgKiBCdWlsZCB0aGUgdW5sb2dnZWQgcmVsYXRpb24gaGFzaCBpZiB0aGUgcGFy ZW50IHBhdGggaXMgZWl0aGVyCisJCSAqICRQR0RBVEEvYmFzZSBvciBhIHRhYmxlc3BhY2Ug dmVyc2lvbiBwYXRoLgorCQkgKi8KKwkJaWYgKHN0cm5jbXAocGF0aCwgIi4vYmFzZSIsIHBh cmVudFBhdGhMZW4pID09IDAgfHwKKwkJCShwYXJlbnRQYXRoTGVuID49IChzaXplb2YoVEFC TEVTUEFDRV9WRVJTSU9OX0RJUkVDVE9SWSkgLSAxKSAmJgorCQkJIHN0cm5jbXAodW5sb2dn ZWREZWxpbSAtIChzaXplb2YoVEFCTEVTUEFDRV9WRVJTSU9OX0RJUkVDVE9SWSkgLSAxKSwK KwkJCQkJIFRBQkxFU1BBQ0VfVkVSU0lPTl9ESVJFQ1RPUlksCisJCQkJCSBzaXplb2YoVEFC TEVTUEFDRV9WRVJTSU9OX0RJUkVDVE9SWSkgLSAxKSA9PSAwKSkKKwkJCXVubG9nZ2VkSGFz aCA9IFJlc2V0VW5sb2dnZWRSZWxhdGlvbnNIYXNoKHBhdGgpOworCX0KIAogCWRpciA9IEFs bG9jYXRlRGlyKHBhdGgpOwogCXdoaWxlICgoZGUgPSBSZWFkRGlyKGRpciwgcGF0aCkpICE9 IE5VTEwpCkBAIC0xMDA4LDYgKzEwNDAsMTUgQEAgc2VuZERpcihjb25zdCBjaGFyICpwYXRo LCBpbnQgYmFzZXBhdGhsZW4sIGJvb2wgc2l6ZW9ubHksIExpc3QgKnRhYmxlc3BhY2VzLAog CQlpZiAoZXhjbHVkZUZvdW5kKQogCQkJY29udGludWU7CiAKKwkJLyogRXhjbHVkZSBhbGwg Zm9ya3MgZm9yIHVubG9nZ2VkIHRhYmxlcyBleGNlcHQgdGhlIGluaXQgZm9yay4gKi8KKwkJ aWYgKHVubG9nZ2VkSGFzaCAmJiBSZXNldFVubG9nZ2VkUmVsYXRpb25zTWF0Y2goCisJCQkJ dW5sb2dnZWRIYXNoLCBkZS0+ZF9uYW1lKSA9PSB1bmxvZ2dlZE90aGVyKQorCQl7CisJCQll bG9nKERFQlVHMiwgInVubG9nZ2VkIHJlbGF0aW9uIGZpbGUgXCIlc1wiIGV4Y2x1ZGVkIGZy b20gYmFja3VwIiwKKwkJCQkgZGUtPmRfbmFtZSk7CisJCQljb250aW51ZTsKKwkJfQorCiAJ CXNucHJpbnRmKHBhdGhidWYsIHNpemVvZihwYXRoYnVmKSwgIiVzLyVzIiwgcGF0aCwgZGUt PmRfbmFtZSk7CiAKIAkJLyogU2tpcCBwZ19jb250cm9sIGhlcmUgdG8gYmFjayB1cCBpdCBs YXN0ICovCkBAIC0xMTc3LDYgKzEyMTgsMTEgQEAgc2VuZERpcihjb25zdCBjaGFyICpwYXRo LCBpbnQgYmFzZXBhdGhsZW4sIGJvb2wgc2l6ZW9ubHksIExpc3QgKnRhYmxlc3BhY2VzLAog CQkJCQkoZXJybXNnKCJza2lwcGluZyBzcGVjaWFsIGZpbGUgXCIlc1wiIiwgcGF0aGJ1Zikp KTsKIAl9CiAJRnJlZURpcihkaXIpOworCisJLyogRnJlZSB0aGUgaGFzaCBjb250YWluaW5n IHVubG9nZ2VkIHRhYmxlcywgaWYgaXQgd2FzIGNyZWF0ZWQgKi8KKwlpZiAodW5sb2dnZWRI YXNoICE9IE5VTEwpCisJCWhhc2hfZGVzdHJveSh1bmxvZ2dlZEhhc2gpOworCiAJcmV0dXJu IHNpemU7CiB9CiAKZGlmZiAtLWdpdCBhL3NyYy9iaW4vcGdfYmFzZWJhY2t1cC90LzAxMF9w Z19iYXNlYmFja3VwLnBsIGIvc3JjL2Jpbi9wZ19iYXNlYmFja3VwL3QvMDEwX3BnX2Jhc2Vi YWNrdXAucGwKaW5kZXggY2RmNGY1YmUzNy4uNDU1YzdmY2EwZCAxMDA2NDQKLS0tIGEvc3Jj L2Jpbi9wZ19iYXNlYmFja3VwL3QvMDEwX3BnX2Jhc2ViYWNrdXAucGwKKysrIGIvc3JjL2Jp bi9wZ19iYXNlYmFja3VwL3QvMDEwX3BnX2Jhc2ViYWNrdXAucGwKQEAgLTQsNyArNCw3IEBA IHVzZSBDd2Q7CiB1c2UgQ29uZmlnOwogdXNlIFBvc3RncmVzTm9kZTsKIHVzZSBUZXN0TGli OwotdXNlIFRlc3Q6Ok1vcmUgdGVzdHMgPT4gNzk7Cit1c2UgVGVzdDo6TW9yZSB0ZXN0cyA9 PiA4NzsKIAogcHJvZ3JhbV9oZWxwX29rKCdwZ19iYXNlYmFja3VwJyk7CiBwcm9ncmFtX3Zl cnNpb25fb2soJ3BnX2Jhc2ViYWNrdXAnKTsKQEAgLTY2LDYgKzY2LDE2IEBAIGZvcmVhY2gg bXkgJGZpbGVuYW1lICgKICMgcG9zaXRpdmUuCiAkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3Jl cycsICdTRUxFQ1QgMTsnKTsKIAorIyBDcmVhdGUgYW4gdW5sb2dnZWQgdGFibGUgdG8gdGVz dCB0aGF0IGZvcmtzIG90aGVyIHRoYW4gaW5pdCBhcmUgbm90IGNvcGllZC4KKyRub2RlLT5z YWZlX3BzcWwoJ3Bvc3RncmVzJywgJ0NSRUFURSBVTkxPR0dFRCBUQUJMRSBiYXNlX3VubG9n Z2VkIChpZCBpbnQpJyk7CisKK215ICRiYXNlVW5sb2dnZWRQYXRoID0gJG5vZGUtPnNhZmVf cHNxbCgncG9zdGdyZXMnLAorCXF7c2VsZWN0IHBnX3JlbGF0aW9uX2ZpbGVwYXRoKCdiYXNl X3VubG9nZ2VkJyl9KTsKKworIyBNYWtlIHN1cmUgbWFpbiBhbmQgaW5pdCBmb3JrcyBleGlz dAorb2soLWYgIiRwZ2RhdGEvJHtiYXNlVW5sb2dnZWRQYXRofV9pbml0IiwgJ3VubG9nZ2Vk IGluaXQgZm9yayBpbiBiYXNlJyk7CitvaygtZiAiJHBnZGF0YS8kYmFzZVVubG9nZ2VkUGF0 aCIsICd1bmxvZ2dlZCBtYWluIGZvcmsgaW4gYmFzZScpOworCiAkbm9kZS0+Y29tbWFuZF9v ayhbICdwZ19iYXNlYmFja3VwJywgJy1EJywgIiR0ZW1wZGlyL2JhY2t1cCIsICctWCcsICdu b25lJyBdLAogCSdwZ19iYXNlYmFja3VwIHJ1bnMnKTsKIG9rKC1mICIkdGVtcGRpci9iYWNr dXAvUEdfVkVSU0lPTiIsICdiYWNrdXAgd2FzIGNyZWF0ZWQnKTsKQEAgLTk2LDYgKzEwNiwx MiBAQCBmb3JlYWNoIG15ICRmaWxlbmFtZSAoCiAJb2soIS1mICIkdGVtcGRpci9iYWNrdXAv JGZpbGVuYW1lIiwgIiRmaWxlbmFtZSBub3QgY29waWVkIik7CiB9CiAKKyMgVW5sb2dnZWQg cmVsYXRpb24gZm9ya3Mgb3RoZXIgdGhhbiBpbml0IHNob3VsZCBub3QgYmUgY29waWVkCitv aygtZiAiJHRlbXBkaXIvYmFja3VwLyR7YmFzZVVubG9nZ2VkUGF0aH1faW5pdCIsCisJJ3Vu bG9nZ2VkIGluaXQgZm9yayBpbiBiYWNrdXAnKTsKK29rKCEtZiAiJHRlbXBkaXIvYmFja3Vw LyRiYXNlVW5sb2dnZWRQYXRoIiwKKwkndW5sb2dnZWQgbWFpbiBmb3JrIG5vdCBpbiBiYWNr dXAnKTsKKwogIyBNYWtlIHN1cmUgZXhpc3RpbmcgYmFja3VwX2xhYmVsIHdhcyBpZ25vcmVk LgogaXNudChzbHVycF9maWxlKCIkdGVtcGRpci9iYWNrdXAvYmFja3VwX2xhYmVsIiksCiAJ J0RPTk9UQ09QWScsICdleGlzdGluZyBiYWNrdXBfbGFiZWwgbm90IGNvcGllZCcpOwpAQCAt MTQ3LDcgKzE2Myw3IEBAIHVubGluayAiJHBnZGF0YS8kc3VwZXJsb25nbmFtZSI7CiAjIHNr aXAgb24gV2luZG93cy4KIFNLSVA6CiB7Ci0Jc2tpcCAic3ltbGlua3Mgbm90IHN1cHBvcnRl ZCBvbiBXaW5kb3dzIiwgMTEgaWYgKCR3aW5kb3dzX29zKTsKKwlza2lwICJzeW1saW5rcyBu b3Qgc3VwcG9ydGVkIG9uIFdpbmRvd3MiLCAxNSBpZiAoJHdpbmRvd3Nfb3MpOwogCiAJIyBN b3ZlIHBnX3JlcGxzbG90IG91dCBvZiAkcGdkYXRhIGFuZCBjcmVhdGUgYSBzeW1saW5rIHRv IGl0LgogCSRub2RlLT5zdG9wOwpAQCAtMTc3LDYgKzE5MywxOSBAQCBTS0lQOgogCW15IEB0 YmxzcGNfdGFycyA9IGdsb2IgIiR0ZW1wZGlyL3RhcmJhY2t1cDIvWzAtOV0qLnRhciI7CiAJ aXMoc2NhbGFyKEB0YmxzcGNfdGFycyksIDEsICdvbmUgdGFibGVzcGFjZSB0YXIgd2FzIGNy ZWF0ZWQnKTsKIAorCSMgQ3JlYXRlIGFuIHVubG9nZ2VkIHRhYmxlIHRvIHRlc3QgdGhhdCBm b3JrcyBvdGhlciB0aGFuIGluaXQgYXJlIG5vdCBjb3BpZWQuCisJJG5vZGUtPnNhZmVfcHNx bCgncG9zdGdyZXMnLAorCQknQ1JFQVRFIFVOTE9HR0VEIFRBQkxFIHRibHNwYzFfdW5sb2dn ZWQgKGlkIGludCkgVEFCTEVTUEFDRSB0YmxzcGMxOycpOworCisJbXkgJHRibHNwYzFVbmxv Z2dlZFBhdGggPSAkbm9kZS0+c2FmZV9wc3FsKAorCQkncG9zdGdyZXMnLCBxe3NlbGVjdCBw Z19yZWxhdGlvbl9maWxlcGF0aCgndGJsc3BjMV91bmxvZ2dlZCcpfSk7CisKKwkjIE1ha2Ug c3VyZSBtYWluIGFuZCBpbml0IGZvcmtzIGV4aXN0CisJb2soLWYgIiRwZ2RhdGEvJHt0Ymxz cGMxVW5sb2dnZWRQYXRofV9pbml0IiwKKwkJJ3VubG9nZ2VkIGluaXQgZm9yayBpbiB0YWJs ZXNwYWNlJyk7CisJb2soLWYgIiRwZ2RhdGEvJHRibHNwYzFVbmxvZ2dlZFBhdGgiLAorCQkn dW5sb2dnZWQgbWFpbiBmb3JrIGluIHRhYmxlc3BhY2UnKTsKKwogCSRub2RlLT5jb21tYW5k X2ZhaWxzKAogCQlbICdwZ19iYXNlYmFja3VwJywgJy1EJywgIiR0ZW1wZGlyL2JhY2t1cDEi LCAnLUZwJyBdLAogCQkncGxhaW4gZm9ybWF0IHdpdGggdGFibGVzcGFjZXMgZmFpbHMgd2l0 aG91dCB0YWJsZXNwYWNlIG1hcHBpbmcnKTsKQEAgLTE5NSwxMSArMjI0LDIwIEBAIFNLSVA6 CiAJCSJ0YWJsZXNwYWNlIHN5bWxpbmsgd2FzIHVwZGF0ZWQiKTsKIAljbG9zZWRpciAkZGg7 CiAKKwkjIFVubG9nZ2VkIHJlbGF0aW9uIGZvcmtzIG90aGVyIHRoYW4gaW5pdCBzaG91bGQg bm90IGJlIGNvcGllZAorCW15ICgkdGJsc3BjMVVubG9nZ2VkQmFja3VwUGF0aCkgPSAkdGJs c3BjMVVubG9nZ2VkUGF0aCA9fiAvW15cL10qXC9bXlwvXSpcL1teXC9dKiQvZzsKKworCW9r KC1mICIkdGVtcGRpci90YmFja3VwL3RibHNwYzEvJHt0YmxzcGMxVW5sb2dnZWRCYWNrdXBQ YXRofV9pbml0IiwKKwkJJ3VubG9nZ2VkIGluaXQgZm9yayBpbiB0YWJsZXNwYWNlIGJhY2t1 cCcpOworCW9rKCEtZiAiJHRlbXBkaXIvdGJhY2t1cC90YmxzcGMxLyR0YmxzcGMxVW5sb2dn ZWRCYWNrdXBQYXRoIiwKKwkJJ3VubG9nZ2VkIG1haW4gZm9yayBub3QgaW4gdGFibGVzcGFj ZSBiYWNrdXAnKTsKKwogCW9rKCAtZCAiJHRlbXBkaXIvYmFja3VwMS9wZ19yZXBsc2xvdCIs CiAJCSdwZ19yZXBsc2xvdCBzeW1saW5rIGNvcGllZCBhcyBkaXJlY3RvcnknKTsKIAogCW1r ZGlyICIkdGVtcGRpci90Ymw9c3BjMiI7CiAJJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMn LCAiRFJPUCBUQUJMRSB0ZXN0MTsiKTsKKwkkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3Jlcycs ICJEUk9QIFRBQkxFIHRibHNwYzFfdW5sb2dnZWQ7Iik7CiAJJG5vZGUtPnNhZmVfcHNxbCgn cG9zdGdyZXMnLCAiRFJPUCBUQUJMRVNQQUNFIHRibHNwYzE7Iik7CiAJJG5vZGUtPnNhZmVf cHNxbCgncG9zdGdyZXMnLAogCQkiQ1JFQVRFIFRBQkxFU1BBQ0UgdGJsc3BjMiBMT0NBVElP TiAnJHNob3J0ZXJfdGVtcGRpci90Ymw9c3BjMic7Iik7Cg== --------------BAFE0599E2AF18F83F079025--