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.96) (envelope-from ) id 1whGFf-00078B-0u for pgsql-hackers@arkaria.postgresql.org; Wed, 08 Jul 2026 00:35:00 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1whGEd-003uGA-1v for pgsql-hackers@arkaria.postgresql.org; Wed, 08 Jul 2026 00:33:56 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1whGEd-003uG1-0N for pgsql-hackers@lists.postgresql.org; Wed, 08 Jul 2026 00:33:56 +0000 Received: from smtp.outgoing.loopia.se ([93.188.3.37]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.98.2) (envelope-from ) id 1whGEa-000000008Up-3dgI for pgsql-hackers@postgresql.org; Wed, 08 Jul 2026 00:33:55 +0000 Received: from s807.loopia.se (localhost [127.0.0.1]) by s807.loopia.se (Postfix) with ESMTP id 68D4B6504D3 for ; Wed, 08 Jul 2026 02:33:52 +0200 (CEST) Received: from s981.loopia.se (unknown [172.22.191.6]) by s807.loopia.se (Postfix) with ESMTP id 49B70650AEC; Wed, 08 Jul 2026 02:33:52 +0200 (CEST) Received: from localhost (unknown [172.22.191.5]) by s981.loopia.se (Postfix) with ESMTP id 3F3E522B16CB; Wed, 08 Jul 2026 02:33:52 +0200 (CEST) X-Virus-Scanned: amavis at amavis.loopia.se X-Spam-Flag: NO X-Spam-Score: -1.2 X-Spam-Level: X-Spam-Status: No, score=-1.2 tagged_above=-999 required=6.2 tests=[ALL_TRUSTED=-1, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1] autolearn=disabled Authentication-Results: s474.loopia.se (amavis); dkim=pass (2048-bit key) header.d=proxel.se Received: from s934.loopia.se ([172.22.191.6]) by localhost (s474.loopia.se [172.22.190.14]) (amavis, port 10024) with LMTP id lzddQG7-1eMH; Wed, 8 Jul 2026 02:32:00 +0200 (CEST) X-Loopia-Auth: user X-Loopia-User: andreas@proxel.se X-Loopia-Originating-IP: 147.28.75.140 Received: from [192.168.0.186] (customer-147-28-75-140.stosn.net [147.28.75.140]) (Authenticated sender: andreas@proxel.se) by s934.loopia.se (Postfix) with ESMTPSA id C1FE4917F08; Wed, 08 Jul 2026 02:31:59 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=proxel.se; s=loopiadkim1707418970; t=1783470719; bh=vP3bW7wD60+nhTQBtg+Rj1UtPDzLsbu47ke/9Kqx41k=; h=Date:Subject:To:References:Cc:From:In-Reply-To; b=Zf8+RCxggL+KStvfgp+B/bqd6Is0TeAIYkcEfwb9q5ae8BV3FhrMofrVuajR4fn6g DTC0WOn7V4nixDGC6njAWQGMOxghm7vv4fswKB7eIJ0/e0W3tnBuBgHcQdzC9kXJf8 MZ+fcfqrLXxDAYRDbUO/ZzL1GFIijx92PKs3+cwxoCu8QiQFmuJj/o0V33yW0Ot06W 0DGcZSElw3meRdGVkltCeUXYSsuHfMUchPvp85EruLfM0BdjZjdarQA+qgEJu5QQyW Fn4OS291jEGzItyMdnRdJsKXNiS9Rb5Pqlt19ZO9EIBOC0ae7xb0vii9rXhy5DpwCn OV9YkCntyAy3Q== Content-Type: multipart/mixed; boundary="------------Kqnll0RAJonusX0P8WqI7VHg" Message-ID: <725d26a1-a604-4cf4-8cf4-3dfd532e2523@proxel.se> Date: Wed, 8 Jul 2026 02:31:59 +0200 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: PoC: VALGRIND_MAKE_MEM_NOACCESS for dynamic shared memory To: Tomas Vondra References: Content-Language: en-US Cc: Andres Freund , pgsql-hackers From: Andreas Karlsson In-Reply-To: List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk This is a multi-part message in MIME format. --------------Kqnll0RAJonusX0P8WqI7VHg Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit Hi! This looks useful so I took a stab at continuing this work plus adding NOACCESS sentinels to shared memory allocated in the main segment with the ShmemAllocator. For the ShmemAllocator I had originally planned to mark all memory as NOACCESS and then have ShmemAllocRaw() mark only the allocated regions as accessible but that did not work with legacy allocations (e.g. calling ShmemAlloc() directly) and EXEC_BAKCEND as there is no way to know where those regions were as they are not in ShmemIndex. I personally think the solution I went with instead, of jsut adding 32 NOACESS bytes at the end of each allocation in shared memory is good enough even if it does not cover all padding bytes like my old solution used to do. What do you think? Is the current solution good enough? I preferred my original idea of starting out with everything NOACCESS but EXEC_BAKCEND made that painful to implement. For shm_toc I fixed the issues pointed out be Andres (the padding issue and that we can have shm_toc_lookup() set NOACCESS) and made sure we clear all NOACCESS sentinels on dsm_deatch(). The clearing of the NOACCESS in dsm_detach() felt a bit ugly but I am not sure there is any better solution. I have also attached a third patch which contains my own extension which I used during development in case anyone would want to use it too. It adds three functions which can do out of bounds access to an array of 10 32-bit integers. For example the function call below triggers a Valgrind error when called with an index > 9. SELECT valgrind_shmem_shm_toc_fg_get(10); The extension is just a quick and dirty hack I used to test things out, and nothing I think should get committed as we do not have any test cases for Valgrind for anything else either. On 5/4/26 16:21, Tomas Vondra wrote: >> I assume the issue is just that the workers don't have the NOACCESS markers? I >> think you'd need to do them in every process using the shm_toc. Either by >> doing it in shm_toc_attach() or in shm_toc(). I do not think you can do it in shm_toc_attach() because there can be new allocations between shm_toc_attach() and shm_toc_lookup() so my patch adds the NOACESS marker in shm_toc_lookup() which should be safe. So NOACCESS markers are added in both shm_toc_allocate() and shm_toc_lookup() in my patch. Sadly it cannot take alignment correctly into account since we do not save that in the TOC (see below). > Right, but it'd also need to know how long the entry is. Which AFAIK it > does not. We don't want to redo the calculation in every worker, but we > might add a "len" field to the toc entry. Not without changing the API and unifying shm_toc_allocate() and shm_toc_insert() since by the time we create a TOC entry we have thrown away the size of the allocation. I would not mind changing this API but I think I would need to understand why it is like that before changing it. It does not feel good to change an API just for Valgrind. Any idea why these two functions are split and why they are not just one function call? >> Which means that you'll often have a up to 32byte pad at the end of the >> (ALIGNOF_BUFFER=32) allocation already. I don't care about the waste, but the >> ALIGNOF_BUFFER padding will often prevent detecting smaller out-of-bounds >> accesses. > > Good point. I forgot about this alignment rounding. I don't care about > the waste either (it'd be a bit silly in a valgrind build anyway), but > not catching smaller mistakes would not be great. My version fixes this, but is not able to fix this in shm_toc_lookup() as I mentioned above due to the lack of a length field for the allocation in the TOC. -- Andreas Karlsson Percona --------------Kqnll0RAJonusX0P8WqI7VHg Content-Type: text/x-patch; charset=UTF-8; name="v2-0001-valgrind-Add-NOACCESS-sentinels-for-shm_toc-entri.patch" Content-Disposition: attachment; filename*0="v2-0001-valgrind-Add-NOACCESS-sentinels-for-shm_toc-entri.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSAxYjY0MzZhMWFhYWJiYzRlOWQ1MGY3ZGQ0OWY0MmFkNmQ4NjE0NTM3IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb21hcyBWb25kcmEgPHRvbWFzQHZvbmRyYS5tZT4K RGF0ZTogU2F0LCAyIE1heSAyMDI2IDIzOjA5OjAwICswMjAwClN1YmplY3Q6IFtQQVRDSCB2 MiAxLzNdIHZhbGdyaW5kOiBBZGQgTk9BQ0NFU1Mgc2VudGluZWxzIGZvciBzaG1fdG9jIGVu dHJpZXMKCldoZW4gYnVpbHQgd2l0aCBVU0VfVkFMR1JJTkQgYWRkIGEgY291cGxlIE5PQUND RVNTIGJ5dGVzIGFmdGVyIGVhY2gKZW50cnkgYWxsb2NhdGVkIGluIGEgc2htX3RvYyBmcm9t IHRoZSBzZWdtZW50LiBTaW5jZSBtYXJraW5ncyBhcmUgbm90CnNoYXJlZCBiZXR3ZWVuIHBy b2Nlc3NlcyB0aGV5IGFyZSBlaXRoZXIgc2V0IHdoZW4gYSBwcm9jZXNzIGFsbG9jYXRlcyBv cgp3aGVuIGEgcHJvY2VzcyBsb29rcyB1cCBhbiBhbGxvY2F0aW9uIGluIHRoZSB0b2MuCgpC dXQgYXMgd2UgaGF2ZSBub3Qgc2F2ZWQgdGhlIHNpemUgb2YgYW4gYWxsb2NhdGlvbiBpbiB0 aGUgdG9jIHdlIG5lZWQKdG8sIG9uIGxvb2t1cCwgYmFzZSB3aGVyZSB3ZSBzZXQgdGhlIHNl bnRpbmVsIG9uIHdoZXJlIHRoZSBzdGFydCBvZiB0aGUKZm9sbG93aW5nIGFsbG9jYXRpb24g aXMgc28gYW55IHBhZGRpbmcgd2lsbCBjYXVzZSBhIGdhcCBiZWZvcmUgdGhlCnNlbnRpbmVs LiBUaGlzIGlzIGZhciBmcm9tIGlkZWFsIGJ1dCBiZXR0ZXIgdGhhbiBub3RoaW5nLgoKV2Ug YWxzbyBuZWVkIHRvIG1ha2Ugc3VyZSB0byBjbGVhciBhbGwgTk9BQ0NFU1MgYnl0ZXMgd2hl biBkZXRhY2hpbmcKZnJvbSBhIERTTSBzZWdtZW50IHNpbmNlIGEgc2htX3RvYyBkb2VzIG5v dCBrbm93IHdoZW4gaXQgd2FzIGRlc3Ryb3llZApvciBkZWF0Y2hlZC4KCkF1dGhvcjogVG9t YXMgVm9uZHJhIDx0b21hc0B2b25kcmEubWU+CkF1dGhvcjogQW5kcmVhcyBLYXJsc3NvbiA8 YW5kcmVhc0Bwcm94ZWwuc2U+Ci0tLQogc3JjL2JhY2tlbmQvc3RvcmFnZS9pcGMvZHNtLmMg ICAgIHwgIDcgKysrKysrCiBzcmMvYmFja2VuZC9zdG9yYWdlL2lwYy9zaG1fdG9jLmMgfCAz OSArKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tCiAyIGZpbGVzIGNoYW5nZWQsIDQy IGluc2VydGlvbnMoKyksIDQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvc3RvcmFnZS9pcGMvZHNtLmMgYi9zcmMvYmFja2VuZC9zdG9yYWdlL2lwYy9kc20uYwpp bmRleCA4YjY5ZGY0ZmYyNi4uZjQ0N2QxNTQzZTMgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5k L3N0b3JhZ2UvaXBjL2RzbS5jCisrKyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvaXBjL2RzbS5j CkBAIC00NSw2ICs0NSw3IEBACiAjaW5jbHVkZSAic3RvcmFnZS9zaG1lbS5oIgogI2luY2x1 ZGUgInN0b3JhZ2Uvc3Vic3lzdGVtcy5oIgogI2luY2x1ZGUgInV0aWxzL2ZyZWVwYWdlLmgi CisjaW5jbHVkZSAidXRpbHMvbWVtZGVidWcuaCIKICNpbmNsdWRlICJ1dGlscy9tZW11dGls cy5oIgogI2luY2x1ZGUgInV0aWxzL3Jlc293bmVyLmgiCiAKQEAgLTg0Niw2ICs4NDcsMTIg QEAgZHNtX2RldGFjaChkc21fc2VnbWVudCAqc2VnKQogCSAqLwogCWlmIChzZWctPm1hcHBl ZF9hZGRyZXNzICE9IE5VTEwpCiAJeworCQkvKgorCQkgKiBXZSBuZWVkIHRvIGNsZWFyIHVw IE5PQUNDRVNTIHJlZ2lvbnMgc2V0IGJ5IHNobV90b2MgYXMgc2htX3RvY3MKKwkJICogaGF2 ZSBubyBmdW5jdGlvbiBmb3IgZGVhdGNoaW5nIG9yIGRlc3Ryb3lpbmcuCisJCSAqLworCQlW QUxHUklORF9NQUtFX01FTV9ERUZJTkVEKHNlZy0+bWFwcGVkX2FkZHJlc3MsIHNlZy0+bWFw cGVkX3NpemUpOworCiAJCWlmICghaXNfbWFpbl9yZWdpb25fZHNtX2hhbmRsZShzZWctPmhh bmRsZSkpCiAJCQlkc21faW1wbF9vcChEU01fT1BfREVUQUNILCBzZWctPmhhbmRsZSwgMCwg JnNlZy0+aW1wbF9wcml2YXRlLAogCQkJCQkJJnNlZy0+bWFwcGVkX2FkZHJlc3MsICZzZWct Pm1hcHBlZF9zaXplLCBXQVJOSU5HKTsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3N0b3Jh Z2UvaXBjL3NobV90b2MuYyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvaXBjL3NobV90b2MuYwpp bmRleCAyZjlmYmIwYTUxOS4uY2YyNDBjNDgyYzYgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5k L3N0b3JhZ2UvaXBjL3NobV90b2MuYworKysgYi9zcmMvYmFja2VuZC9zdG9yYWdlL2lwYy9z aG1fdG9jLmMKQEAgLTE2LDYgKzE2LDcgQEAKICNpbmNsdWRlICJwb3J0L2F0b21pY3MuaCIK ICNpbmNsdWRlICJzdG9yYWdlL3NobV90b2MuaCIKICNpbmNsdWRlICJzdG9yYWdlL3NwaW4u aCIKKyNpbmNsdWRlICJ1dGlscy9tZW1kZWJ1Zy5oIgogCiB0eXBlZGVmIHN0cnVjdCBzaG1f dG9jX2VudHJ5CiB7CkBAIC03NCw2ICs3NSwxMyBAQCBzaG1fdG9jX2F0dGFjaCh1aW50NjQg bWFnaWMsIHZvaWQgKmFkZHJlc3MpCiAJcmV0dXJuIHRvYzsKIH0KIAorLyogV2l0aCB2YWxn cmluZCwgd2Ugd2FudCB0byBhZGQgYSBjb3VwbGUgTk9BQ0NFU1MgYnl0ZXMgKi8KKyNpZmRl ZiBVU0VfVkFMR1JJTkQKKyNkZWZpbmUgTlVNX05PQUNDRVNTX0JZVEVTIDMyCisjZWxzZQor I2RlZmluZSBOVU1fTk9BQ0NFU1NfQllURVMgMAorI2VuZGlmCisKIC8qCiAgKiBBbGxvY2F0 ZSBzaGFyZWQgbWVtb3J5IGZyb20gYSBzZWdtZW50IG1hbmFnZWQgYnkgYSB0YWJsZSBvZiBj b250ZW50cy4KICAqCkBAIC04OCw2ICs5Niw3IEBAIHZvaWQgKgogc2htX3RvY19hbGxvY2F0 ZShzaG1fdG9jICp0b2MsIFNpemUgbmJ5dGVzKQogewogCXZvbGF0aWxlIHNobV90b2MgKnZ0 b2MgPSB0b2M7CisJU2l6ZQkJcmVxYnl0ZXM7CiAJU2l6ZQkJdG90YWxfYnl0ZXM7CiAJU2l6 ZQkJYWxsb2NhdGVkX2J5dGVzOwogCVNpemUJCW5lbnRyeTsKQEAgLTk5LDcgKzEwOCw3IEBA IHNobV90b2NfYWxsb2NhdGUoc2htX3RvYyAqdG9jLCBTaXplIG5ieXRlcykKIAkgKiBwcm9w ZXIgZGVmaW5pdGlvbiBmb3IgdGhlIG1pbmltdW0gdG8gbWFrZSBhdG9taWMgb3BzIHNhZmUs IGJ1dAogCSAqIEJVRkZFUkFMSUdOIG91Z2h0IHRvIGJlIGVub3VnaC4KIAkgKi8KLQluYnl0 ZXMgPSBCVUZGRVJBTElHTihuYnl0ZXMpOworCXJlcWJ5dGVzID0gQlVGRkVSQUxJR04obmJ5 dGVzICsgTlVNX05PQUNDRVNTX0JZVEVTKTsKIAogCVNwaW5Mb2NrQWNxdWlyZSgmdG9jLT50 b2NfbXV0ZXgpOwogCkBAIC0xMTAsMTggKzExOSwyNCBAQCBzaG1fdG9jX2FsbG9jYXRlKHNo bV90b2MgKnRvYywgU2l6ZSBuYnl0ZXMpCiAJCSsgYWxsb2NhdGVkX2J5dGVzOwogCiAJLyog Q2hlY2sgZm9yIG1lbW9yeSBleGhhdXN0aW9uIGFuZCBvdmVyZmxvdy4gKi8KLQlpZiAodG9j X2J5dGVzICsgbmJ5dGVzID4gdG90YWxfYnl0ZXMgfHwgdG9jX2J5dGVzICsgbmJ5dGVzIDwg dG9jX2J5dGVzKQorCWlmICh0b2NfYnl0ZXMgKyByZXFieXRlcyA+IHRvdGFsX2J5dGVzIHx8 IHRvY19ieXRlcyArIHJlcWJ5dGVzIDwgdG9jX2J5dGVzKQogCXsKIAkJU3BpbkxvY2tSZWxl YXNlKCZ0b2MtPnRvY19tdXRleCk7CiAJCWVyZXBvcnQoRVJST1IsCiAJCQkJKGVycmNvZGUo RVJSQ09ERV9PVVRfT0ZfTUVNT1JZKSwKIAkJCQkgZXJybXNnKCJvdXQgb2Ygc2hhcmVkIG1l bW9yeSIpKSk7CiAJfQotCXZ0b2MtPnRvY19hbGxvY2F0ZWRfYnl0ZXMgKz0gbmJ5dGVzOwor CXZ0b2MtPnRvY19hbGxvY2F0ZWRfYnl0ZXMgKz0gcmVxYnl0ZXM7CiAKIAlTcGluTG9ja1Jl bGVhc2UoJnRvYy0+dG9jX211dGV4KTsKIAotCXJldHVybiAoKGNoYXIgKikgdG9jKSArICh0 b3RhbF9ieXRlcyAtIGFsbG9jYXRlZF9ieXRlcyAtIG5ieXRlcyk7CisjaWZkZWYgVVNFX1ZB TEdSSU5ECisJLyogTWFrZSB0aGUgYnl0ZXMgYXQgdGhlIGVuZCBuby1hY2Nlc3MgKi8KKwlW QUxHUklORF9NQUtFX01FTV9OT0FDQ0VTUygoKGNoYXIgKikgdG9jKSArICh0b3RhbF9ieXRl cyAtIGFsbG9jYXRlZF9ieXRlcyAtIHJlcWJ5dGVzICsgbmJ5dGVzKSwKKwkJCQkJCQkgICBy ZXFieXRlcyAtIG5ieXRlcyk7CisjZW5kaWYKKworCXJldHVybiAoKGNoYXIgKikgdG9jKSAr ICh0b3RhbF9ieXRlcyAtIGFsbG9jYXRlZF9ieXRlcyAtIHJlcWJ5dGVzKTsKIH0KIAogLyoK QEAgLTI1Miw3ICsyNjcsMjAgQEAgc2htX3RvY19sb29rdXAoc2htX3RvYyAqdG9jLCB1aW50 NjQga2V5LCBib29sIG5vRXJyb3IpCiAJZm9yIChpID0gMDsgaSA8IG5lbnRyeTsgKytpKQog CXsKIAkJaWYgKHRvYy0+dG9jX2VudHJ5W2ldLmtleSA9PSBrZXkpCisJCXsKKyNpZmRlZiBV U0VfVkFMR1JJTkQKKwkJCS8qCisJCQkgKiBTaW5jZSB3ZSBkbyBub3Qga25vdyB0aGUgc2l6 ZSBvZiBlbnRyaWVzIHdlIGNhbiBvbmx5IHVzZSB0aGUKKwkJCSAqIHN0YXJ0IG9mIHRoZSBu ZXh0IGVudHJ5IGZvciBzZXR0aW5nIHRoZSBuby1hY2Nlc3Mgc2VudGluZWwuCisJCQkgKi8K KwkJCVNpemUJCW5leHRvZmZzZXQgPSBpID09IDAgPyB0b2MtPnRvY190b3RhbF9ieXRlcyA6 IHRvYy0+dG9jX2VudHJ5W2kgLSAxXS5vZmZzZXQ7CisKKwkJCVZBTEdSSU5EX01BS0VfTUVN X05PQUNDRVNTKCgoY2hhciAqKSB0b2MpICsgbmV4dG9mZnNldCAtIE5VTV9OT0FDQ0VTU19C WVRFUywKKwkJCQkJCQkJCQlOVU1fTk9BQ0NFU1NfQllURVMpOworI2VuZGlmCisKIAkJCXJl dHVybiAoKGNoYXIgKikgdG9jKSArIHRvYy0+dG9jX2VudHJ5W2ldLm9mZnNldDsKKwkJfQog CX0KIAogCS8qIE5vIG1hdGNoaW5nIGVudHJ5IHdhcyBmb3VuZC4gKi8KQEAgLTI3NSw1ICsz MDMsOCBAQCBzaG1fdG9jX2VzdGltYXRlKHNobV90b2NfZXN0aW1hdG9yICplKQogCXN6ID0g YWRkX3NpemUoc3osIG11bF9zaXplKGUtPm51bWJlcl9vZl9rZXlzLCBzaXplb2Yoc2htX3Rv Y19lbnRyeSkpKTsKIAlzeiA9IGFkZF9zaXplKHN6LCBlLT5zcGFjZV9mb3JfY2h1bmtzKTsK IAorCS8qIGFkZCBzcGFjZSBmb3IgRU5PQUNDRVNTIGJ5dGVzLCBOVU1fTk9BQ0NFU1NfQllU RVMgcGVyIGtleSAqLworCXN6ID0gYWRkX3NpemUoc3osIG11bF9zaXplKGUtPm51bWJlcl9v Zl9rZXlzLCBOVU1fTk9BQ0NFU1NfQllURVMpKTsKKwogCXJldHVybiBCVUZGRVJBTElHTihz eik7CiB9Ci0tIAoyLjQzLjAKCg== --------------Kqnll0RAJonusX0P8WqI7VHg Content-Type: text/x-patch; charset=UTF-8; name="v2-0002-valgrind-Add-NOACCESS-sentinels-to-allocations-in.patch" Content-Disposition: attachment; filename*0="v2-0002-valgrind-Add-NOACCESS-sentinels-to-allocations-in.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSA3NTNlMDc3MzliNGUwZTkwNmU4N2YyNGUxNWUyYzIxN2RlMjhmMTdkIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbmRyZWFzIEthcmxzc29uIDxhbmRyZWFzLmthcmxz c29uQHBlcmNvbmEuY29tPgpEYXRlOiBUaHUsIDQgSnVuIDIwMjYgMTM6NTQ6MjIgKzAyMDAK U3ViamVjdDogW1BBVENIIHYyIDIvM10gdmFsZ3JpbmQ6IEFkZCBOT0FDQ0VTUyBzZW50aW5l bHMgdG8gYWxsb2NhdGlvbnMgaW4KIG1haW4gc2hhcmVkIG1lbW9yeQoKV2hlbiBidWlsdCB3 aXRoIFVTRV9WQUxHUklORCB3ZSBoYXZlIHRoZSBTaG1lbUFsbG9jYXRvciBhZGQgYSBOT0FD Q0VTUwpzZW50aW5lbCBhZnRlciBldmVyeSBhbGxvY2F0aW9uIGluIHNoYXJlZCBtZW1vcnku IE9uIEVYRUNfQkFDS0VORCBidWlsZHMKd2Ugc2V0IHVwIHRoZSBzZW50aW5lbHMgd2hlbiB0 aGUgYmFja2VuZCBhdHRhY2hlcyB0byBzaGFyZWQgbWVtb3J5LCBidXQKdGhlbiBvbmx5IGZv ciB0aGluZ3MgaW4gU2htZW1JbmRleCBhbmQgbm90IGZvciBhbGxvY2F0aW9ucyBkb25lIGRp cmVjdGx5CnZpYSBsZWdhY3kgZnVuY3Rpb25zIGxpa2UgU2htZW1BbGxvYygpLgoKQXV0aG9y OiBBbmRyZWFzIEthcmxzc29uIDxhbmRyZWFzQHByb3hlbC5zZT4KLS0tCiBzcmMvYmFja2Vu ZC9zdG9yYWdlL2lwYy9zaG1lbS5jIHwgMzggKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKystCiAxIGZpbGUgY2hhbmdlZCwgMzcgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigt KQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvaXBjL3NobWVtLmMgYi9zcmMv YmFja2VuZC9zdG9yYWdlL2lwYy9zaG1lbS5jCmluZGV4IGYxZjdjZDNhNGZmLi5hNzA3N2Jl MDk3YiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9pcGMvc2htZW0uYworKysg Yi9zcmMvYmFja2VuZC9zdG9yYWdlL2lwYy9zaG1lbS5jCkBAIC0xNDIsNiArMTQyLDcgQEAK ICNpbmNsdWRlICJzdG9yYWdlL3NobWVtX2ludGVybmFsLmgiCiAjaW5jbHVkZSAic3RvcmFn ZS9zcGluLmgiCiAjaW5jbHVkZSAidXRpbHMvYnVpbHRpbnMuaCIKKyNpbmNsdWRlICJ1dGls cy9tZW1kZWJ1Zy5oIgogI2luY2x1ZGUgInV0aWxzL3R1cGxlc3RvcmUuaCIKIAogLyoKQEAg LTI3OSw2ICsyODAsMTMgQEAgc3RhdGljIGJvb2wgQXR0YWNoU2htZW1JbmRleEVudHJ5KFNo bWVtUmVxdWVzdCAqcmVxdWVzdCwgYm9vbCBtaXNzaW5nX29rKTsKIAogRGF0dW0JCXBnX251 bWFfYXZhaWxhYmxlKFBHX0ZVTkNUSU9OX0FSR1MpOwogCisvKiBXaXRoIHZhbGdyaW5kLCB3 ZSB3YW50IHRvIGFkZCBhIGNvdXBsZSBOT0FDQ0VTUyBieXRlcyAqLworI2lmZGVmIFVTRV9W QUxHUklORAorI2RlZmluZSBOT0FDQ0VTU19CWVRFUyAzMgorI2Vsc2UKKyNkZWZpbmUgTk9B Q0NFU1NfQllURVMgMAorI2VuZGlmCisKIC8qCiAgKglTaG1lbVJlcXVlc3RTdHJ1Y3QoKSAt LS0gcmVxdWVzdCBhIG5hbWVkIHNoYXJlZCBtZW1vcnkgYXJlYQogICoKQEAgLTQwNSw5ICs0 MTMsMTQgQEAgU2htZW1HZXRSZXF1ZXN0ZWRTaXplKHZvaWQpCiAJCS8qIHBhZCB0aGUgc3Rh cnQgYWRkcmVzcyBmb3IgYWxpZ25tZW50IGxpa2UgU2htZW1BbGxvY1JhdygpIGRvZXMgKi8K IAkJaWYgKGFsaWdubWVudCA8IFBHX0NBQ0hFX0xJTkVfU0laRSkKIAkJCWFsaWdubWVudCA9 IFBHX0NBQ0hFX0xJTkVfU0laRTsKKwogCQlzaXplID0gVFlQRUFMSUdOKGFsaWdubWVudCwg c2l6ZSk7CiAKIAkJc2l6ZSA9IGFkZF9zaXplKHNpemUsIHJlcXVlc3QtPm9wdGlvbnMtPnNp emUpOworCisjaWYgVVNFX1ZBTEdSSU5ECisJCXNpemUgPSBhZGRfc2l6ZShzaXplLCBOT0FD Q0VTU19CWVRFUyk7CisjZW5kaWYKIAl9CiAKIAlyZXR1cm4gc2l6ZTsKQEAgLTQ5Miw2ICs1 MDUsMjYgQEAgU2htZW1BdHRhY2hSZXF1ZXN0ZWQodm9pZCkKIAkJCWNhbGxiYWNrcy0+YXR0 YWNoX2ZuKGNhbGxiYWNrcy0+b3BhcXVlX2FyZyk7CiAJfQogCisjaWZkZWYgVVNFX1ZBTEdS SU5ECisJeworCQlIQVNIX1NFUV9TVEFUVVMgaHN0YXQ7CisJCVNobWVtSW5kZXhFbnQgKmVu dDsKKworCQloYXNoX3NlcV9pbml0KCZoc3RhdCwgU2htZW1JbmRleCk7CisKKwkJLyoKKwkJ ICogV2hlbiBjb21waWxlZCB3aXRoIEVYRUNfQkFDS0VORCB3ZSBuZWVkIHRvIHJlY3JlYXRl IGFsbCBOT0FDQ0VTUworCQkgKiByZWdpb25zIGluIGVhY2ggYmFja2VuZCwgYnV0IHdlIGNh biBvbmx5IHJlY3JlYXRlIHRob3NlIHdpdGggaW5kZXgKKwkJICogZW50cmllcyBhbmQgbm90 IGFueSBvZiB0aGUgcmVnaW9ucyBmb3IgbWVtb3J5IGFsbG9jYXRlZCBkaXJlY3RseSB3aXRo CisJCSAqIFNobWVtQWxsb2MoKS4KKwkJICovCisJCXdoaWxlICgoZW50ID0gKFNobWVtSW5k ZXhFbnQgKikgaGFzaF9zZXFfc2VhcmNoKCZoc3RhdCkpICE9IE5VTEwpCisJCXsKKwkJCVZB TEdSSU5EX01BS0VfTUVNX05PQUNDRVNTKGVudC0+bG9jYXRpb24gKyBlbnQtPnNpemUsIE5P QUNDRVNTX0JZVEVTKTsKKwkJfQorCX0KKyNlbmRpZgorCiAJTFdMb2NrUmVsZWFzZShTaG1l bUluZGV4TG9jayk7CiAKIAlzaG1lbV9yZXF1ZXN0X3N0YXRlID0gU1JTX0RPTkU7CkBAIC04 MjIsMTEgKzg1NSwxNCBAQCBTaG1lbUFsbG9jUmF3KFNpemUgc2l6ZSwgU2l6ZSBhbGlnbm1l bnQsIFNpemUgKmFsbG9jYXRlZF9zaXplKQogCXJhd1N0YXJ0ID0gU2htZW1BbGxvY2F0b3It PmZyZWVfb2Zmc2V0OwogCW5ld1N0YXJ0ID0gVFlQRUFMSUdOKGFsaWdubWVudCwgcmF3U3Rh cnQpOwogCi0JbmV3RnJlZSA9IG5ld1N0YXJ0ICsgc2l6ZTsKKwluZXdGcmVlID0gbmV3U3Rh cnQgKyBzaXplICsgTk9BQ0NFU1NfQllURVM7CiAJaWYgKG5ld0ZyZWUgPD0gU2htZW1TZWdI ZHItPnRvdGFsc2l6ZSkKIAl7CiAJCW5ld1NwYWNlID0gKGNoYXIgKikgU2htZW1CYXNlICsg bmV3U3RhcnQ7CiAJCVNobWVtQWxsb2NhdG9yLT5mcmVlX29mZnNldCA9IG5ld0ZyZWU7CisK KwkJLyogTWFrZSB0aGUgYnl0ZXMgYXQgdGhlIGVuZCBuby1hY2Nlc3MgKi8KKwkJVkFMR1JJ TkRfTUFLRV9NRU1fTk9BQ0NFU1MobmV3U3BhY2UgKyBzaXplLCBOT0FDQ0VTU19CWVRFUyk7 CiAJfQogCWVsc2UKIAkJbmV3U3BhY2UgPSBOVUxMOwotLSAKMi40My4wCgo= --------------Kqnll0RAJonusX0P8WqI7VHg Content-Type: text/x-patch; charset=UTF-8; name="v2-0003-Toy-extension-to-make-it-easier-to-test-out-of-bo.patch" Content-Disposition: attachment; filename*0="v2-0003-Toy-extension-to-make-it-easier-to-test-out-of-bo.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSBiOGU3MGE1NTI1MWQ5ZGQ1NTkxNDdkZWNhZjk5MjRlZWQ0MzM0N2YyIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbmRyZWFzIEthcmxzc29uIDxhbmRyZWFzLmthcmxz c29uQHBlcmNvbmEuY29tPgpEYXRlOiBTYXQsIDQgSnVsIDIwMjYgMTM6MTc6MTUgKzAyMDAK U3ViamVjdDogW1BBVENIIHYyIDMvM10gVG95IGV4dGVuc2lvbiB0byBtYWtlIGl0IGVhc2ll ciB0byB0ZXN0IG91dCBvZiBib3VuZHMKIGFjY2VzcwoKSSBidWlsdCB0aGlzIGV4dGVuc2lv biBqdXN0IGZvciBteSBwZXJzb25hbCB1c2Ugd2hpbGUgZGV2ZWxvcGluZyBzbyBJCmNhbiB0 cmlnZ2VyIG91dCBvZiBib3VuZHMgYXJyYXkgYWNjZXNzIGJ5IGFjY2Vzc2luZyBhbiBhcnJh eSBpbmRleApvdXRzaWRlIG9mIGEgMTAgZWxlbWVudCBhcnJheSBpbiBzaGFyZWQgbWVtb3J5 LgoKSXQgY2FuIGJlIHVzZWQgdG8gdGVzdCBib3RoIHRoZSBTaG1lbUFsbG9jYXRvciBhbmQg c2htX3RvYywgaW5jbHVkaW5nCmFjY2VzcyBmcm9tIGEgYmFja2dyb3VuZCB3b3JrZXIKLS0t CiBjb250cmliL21lc29uLmJ1aWxkICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEg KwogY29udHJpYi92YWxncmluZF9zaG1lbS9tZXNvbi5idWlsZCAgICAgICAgICAgIHwgIDE4 ICsrCiAuLi4vdmFsZ3JpbmRfc2htZW0vdmFsZ3JpbmRfc2htZW0tLTEuMC5zcWwgICAgfCAg MTYgKysKIGNvbnRyaWIvdmFsZ3JpbmRfc2htZW0vdmFsZ3JpbmRfc2htZW0uYyAgICAgICB8 IDIyNyArKysrKysrKysrKysrKysrKysKIGNvbnRyaWIvdmFsZ3JpbmRfc2htZW0vdmFsZ3Jp bmRfc2htZW0uY29udHJvbCB8ICAgNSArCiA1IGZpbGVzIGNoYW5nZWQsIDI2NyBpbnNlcnRp b25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgY29udHJpYi92YWxncmluZF9zaG1lbS9tZXNv bi5idWlsZAogY3JlYXRlIG1vZGUgMTAwNjQ0IGNvbnRyaWIvdmFsZ3JpbmRfc2htZW0vdmFs Z3JpbmRfc2htZW0tLTEuMC5zcWwKIGNyZWF0ZSBtb2RlIDEwMDY0NCBjb250cmliL3ZhbGdy aW5kX3NobWVtL3ZhbGdyaW5kX3NobWVtLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBjb250cmli L3ZhbGdyaW5kX3NobWVtL3ZhbGdyaW5kX3NobWVtLmNvbnRyb2wKCmRpZmYgLS1naXQgYS9j b250cmliL21lc29uLmJ1aWxkIGIvY29udHJpYi9tZXNvbi5idWlsZAppbmRleCBlYmI3Zjgz ZDhjNS4uMzE1OWM0MDg0YjAgMTAwNjQ0Ci0tLSBhL2NvbnRyaWIvbWVzb24uYnVpbGQKKysr IGIvY29udHJpYi9tZXNvbi5idWlsZApAQCAtNzIsNCArNzIsNSBAQCBzdWJkaXIoJ3RzbV9z eXN0ZW1fdGltZScpCiBzdWJkaXIoJ3VuYWNjZW50JykKIHN1YmRpcigndXVpZC1vc3NwJykK IHN1YmRpcigndmFjdXVtbG8nKQorc3ViZGlyKCd2YWxncmluZF9zaG1lbScpCiBzdWJkaXIo J3htbDInKQpkaWZmIC0tZ2l0IGEvY29udHJpYi92YWxncmluZF9zaG1lbS9tZXNvbi5idWls ZCBiL2NvbnRyaWIvdmFsZ3JpbmRfc2htZW0vbWVzb24uYnVpbGQKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLjViNjIwNmVkMGNiCi0tLSAvZGV2L251bGwKKysr IGIvY29udHJpYi92YWxncmluZF9zaG1lbS9tZXNvbi5idWlsZApAQCAtMCwwICsxLDE4IEBA CisjIENvcHlyaWdodCAoYykgMjAyMi0yMDI2LCBQb3N0Z3JlU1FMIEdsb2JhbCBEZXZlbG9w bWVudCBHcm91cAorCit2YWxncmluZF9zaG1lbV9zb3VyY2VzID0gZmlsZXMoCisgICd2YWxn cmluZF9zaG1lbS5jJywKKykKKwordmFsZ3JpbmRfc2htZW0gPSBzaGFyZWRfbW9kdWxlKCd2 YWxncmluZF9zaG1lbScsCisgIHZhbGdyaW5kX3NobWVtX3NvdXJjZXMsCisgIGNfcGNoOiBw Y2hfcG9zdGdyZXNfaCwKKyAga3dhcmdzOiBjb250cmliX21vZF9hcmdzLAorKQorY29udHJp Yl90YXJnZXRzICs9IHZhbGdyaW5kX3NobWVtCisKK2luc3RhbGxfZGF0YSgKKyAgJ3ZhbGdy aW5kX3NobWVtLS0xLjAuc3FsJywKKyAgJ3ZhbGdyaW5kX3NobWVtLmNvbnRyb2wnLAorICBr d2FyZ3M6IGNvbnRyaWJfZGF0YV9hcmdzLAorKQpkaWZmIC0tZ2l0IGEvY29udHJpYi92YWxn cmluZF9zaG1lbS92YWxncmluZF9zaG1lbS0tMS4wLnNxbCBiL2NvbnRyaWIvdmFsZ3JpbmRf c2htZW0vdmFsZ3JpbmRfc2htZW0tLTEuMC5zcWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAuLjIzNGJlOWIxYjA3Ci0tLSAvZGV2L251bGwKKysrIGIvY29udHJp Yi92YWxncmluZF9zaG1lbS92YWxncmluZF9zaG1lbS0tMS4wLnNxbApAQCAtMCwwICsxLDE2 IEBACisvKiBjb250cmliL3ZhbGdyaW5kX3NobWVtL3ZhbGdyaW5kX3NobWVtLS0xLjEuc3Fs ICovCisKKy0tIGNvbXBsYWluIGlmIHNjcmlwdCBpcyBzb3VyY2VkIGluIHBzcWwsIHJhdGhl ciB0aGFuIHZpYSBDUkVBVEUgRVhURU5TSU9OCitcZWNobyBVc2UgIkNSRUFURSBFWFRFTlNJ T04gdmFsZ3JpbmRfc2htZW0iIHRvIGxvYWQgdGhpcyBmaWxlLiBccXVpdAorCitDUkVBVEUg RlVOQ1RJT04gdmFsZ3JpbmRfc2htZW1fbWFpbl9nZXQoaW50KSBSRVRVUk5TIGludAorQVMg J01PRFVMRV9QQVRITkFNRScKK0xBTkdVQUdFIEMgU1RSSUNUIElNTVVUQUJMRSBQQVJBTExF TCBTQUZFOworCitDUkVBVEUgRlVOQ1RJT04gdmFsZ3JpbmRfc2htZW1fc2htX3RvY19mZ19n ZXQoaW50KSBSRVRVUk5TIGludAorQVMgJ01PRFVMRV9QQVRITkFNRScKK0xBTkdVQUdFIEMg U1RSSUNUIElNTVVUQUJMRSBQQVJBTExFTCBTQUZFOworCitDUkVBVEUgRlVOQ1RJT04gdmFs Z3JpbmRfc2htZW1fc2htX3RvY19iZ19nZXQoaW50KSBSRVRVUk5TIGludAorQVMgJ01PRFVM RV9QQVRITkFNRScKK0xBTkdVQUdFIEMgU1RSSUNUIElNTVVUQUJMRSBQQVJBTExFTCBTQUZF OwpkaWZmIC0tZ2l0IGEvY29udHJpYi92YWxncmluZF9zaG1lbS92YWxncmluZF9zaG1lbS5j IGIvY29udHJpYi92YWxncmluZF9zaG1lbS92YWxncmluZF9zaG1lbS5jCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi42MmQ3ODMzNjJiYwotLS0gL2Rldi9udWxs CisrKyBiL2NvbnRyaWIvdmFsZ3JpbmRfc2htZW0vdmFsZ3JpbmRfc2htZW0uYwpAQCAtMCww ICsxLDIyNyBAQAorI2luY2x1ZGUgInBvc3RncmVzLmgiCisKKyNpbmNsdWRlICJmbWdyLmgi CisjaW5jbHVkZSAibWlzY2FkbWluLmgiCisjaW5jbHVkZSAicG9zdG1hc3Rlci9iZ3dvcmtl ci5oIgorI2luY2x1ZGUgInN0b3JhZ2UvZHNtLmgiCisjaW5jbHVkZSAic3RvcmFnZS9pcGMu aCIKKyNpbmNsdWRlICJzdG9yYWdlL3Byb2MuaCIKKyNpbmNsdWRlICJzdG9yYWdlL3NobV90 b2MuaCIKKyNpbmNsdWRlICJzdG9yYWdlL3NobWVtLmgiCisjaW5jbHVkZSAidXRpbHMvd2Fp dF9ldmVudC5oIgorCitQR19NT0RVTEVfTUFHSUNfRVhUKAorCQkJCQkubmFtZSA9ICJ2YWxn cmluZF9zaG1lbSIsCisJCQkJCS52ZXJzaW9uID0gUEdfVkVSU0lPTgorKTsKKworI2RlZmlu ZQlQR19URVNUX1ZBTEdSSU5EX1NITUVNX01BR0lDIDB4NzQ2ODZmNzIKKworUEdfRlVOQ1RJ T05fSU5GT19WMSh2YWxncmluZF9zaG1lbV9tYWluX2dldCk7CitQR19GVU5DVElPTl9JTkZP X1YxKHZhbGdyaW5kX3NobWVtX3NobV90b2NfZmdfZ2V0KTsKK1BHX0ZVTkNUSU9OX0lORk9f VjEodmFsZ3JpbmRfc2htZW1fc2htX3RvY19iZ19nZXQpOworCitwZ19ub3JldHVybiBleHRl cm4gUEdETExFWFBPUlQgdm9pZCB2YWxncmluZF9zaG1lbV9tYWluKERhdHVtIG1haW5fYXJn KTsKKwordHlwZWRlZiBzdHJ1Y3QKK3sKKwlpbnQzMgkJaW5kZXg7CisJYm9vbAkJZG9uZTsK KwlpbnQzMgkJcmVzdWx0OworfSBXb3JrZXJIZWFkZXI7CisKK3R5cGVkZWYgc3RydWN0Cit7 CisJaW50MzIJCWFbMTBdOworfSBTaG1lbVN0YXRlOworCitzdGF0aWMgU2htZW1TdGF0ZSAq c3RhdGU7CitzdGF0aWMgaW50IHdlX3ZhbGRncmluZF9zaG1lbV9yZXF1ZXN0ID0gMDsKKwor c3RhdGljIHZvaWQKK3NobWVtX3JlcXVlc3Qodm9pZCAqYXJnKQoreworCVNobWVtUmVxdWVz dFN0cnVjdCgubmFtZSA9ICJ2YWxncmluZF9zaG1lbTogc3RhdGUiLAorCQkJCQkgICAuc2l6 ZSA9IHNpemVvZihTaG1lbVN0YXRlKSwKKwkJCQkJICAgLnB0ciA9ICh2b2lkICoqKSAmc3Rh dGUsCisJCSk7Cit9CisKK3N0YXRpYyB2b2lkCitzaG1lbV9pbml0KHZvaWQgKmFyZykKK3sK Kwlmb3IgKGludCBpID0gMDsgaSA8IDEwOyBpKyspCisJCXN0YXRlLT5hW2ldID0gaSAqIDI7 Cit9CisKK3N0YXRpYyBjb25zdCBTaG1lbUNhbGxiYWNrcyBzaG1lbV9jYWxsYmFja3MgPSB7 CisJLnJlcXVlc3RfZm4gPSBzaG1lbV9yZXF1ZXN0LAorCS5pbml0X2ZuID0gc2htZW1faW5p dCwKK307CisKKy8qCisgKiBHZXRzIGFuIGFycmF5IGVsZW1lbnQgZnJvbSBhIHN0cnVjdCBp biB0aGUgbWFpbiBzaGFyZWQgbWVtb3J5LgorICovCitEYXR1bQordmFsZ3JpbmRfc2htZW1f bWFpbl9nZXQoUEdfRlVOQ1RJT05fQVJHUykKK3sKKwlpbnQzMgkJaW5kZXggPSBQR19HRVRB UkdfSU5UMzIoMCk7CisKKwlQR19SRVRVUk5fSU5UMzIoc3RhdGUtPmFbaW5kZXhdKTsKK30K KworLyoKKyAqIEdldHMgYW4gYXJyYXkgZWxlbWVudCBmcm9tIGEgc3RydWN0IGluIGEgc2ht X3RvYyBlbnRyeSBpbiBEU00uCisgKi8KK0RhdHVtCit2YWxncmluZF9zaG1lbV9zaG1fdG9j X2ZnX2dldChQR19GVU5DVElPTl9BUkdTKQoreworCWludDMyCQlpbmRleCA9IFBHX0dFVEFS R19JTlQzMigwKTsKKwlzaG1fdG9jX2VzdGltYXRvciBlOworCVNpemUJCXNlZ3NpemU7CisJ ZHNtX3NlZ21lbnQgKnNlZzsKKwlzaG1fdG9jICAgICp0b2M7CisJU2htZW1TdGF0ZSAqc3Rh dGU7CisJaW50MzIJCXJldDsKKworCXNobV90b2NfaW5pdGlhbGl6ZV9lc3RpbWF0b3IoJmUp OworCXNobV90b2NfZXN0aW1hdGVfY2h1bmsoJmUsIHNpemVvZihTaG1lbVN0YXRlKSk7CisJ c2htX3RvY19lc3RpbWF0ZV9rZXlzKCZlLCAxKTsKKwlzZWdzaXplID0gc2htX3RvY19lc3Rp bWF0ZSgmZSk7CisKKwlzZWcgPSBkc21fY3JlYXRlKHNobV90b2NfZXN0aW1hdGUoJmUpLCAw KTsKKwl0b2MgPSBzaG1fdG9jX2NyZWF0ZShQR19URVNUX1ZBTEdSSU5EX1NITUVNX01BR0lD LCBkc21fc2VnbWVudF9hZGRyZXNzKHNlZyksIHNlZ3NpemUpOworCisJc3RhdGUgPSBzaG1f dG9jX2FsbG9jYXRlKHRvYywgc2l6ZW9mKFNobWVtU3RhdGUpKTsKKwlmb3IgKGludCBpID0g MDsgaSA8IDEwOyBpKyspCisJCXN0YXRlLT5hW2ldID0gaSAqIDM7CisJc2htX3RvY19pbnNl cnQodG9jLCAxLCBzdGF0ZSk7CisKKwlyZXQgPSBzdGF0ZS0+YVtpbmRleF07CisKKwlkc21f ZGV0YWNoKHNlZyk7CisKKwlQR19SRVRVUk5fSU5UMzIocmV0KTsKK30KKworLyoKKyAqIEdl dHMgYW4gYXJyYXkgZWxlbWVudCBmcm9tIGEgc3RydWN0IGluIGEgc2htX3RvYyBlbnRyeSBp biBEU00gaW4gYQorICogYmFja2dyb3VuZCB3b3JrZXIuCisgKi8KK0RhdHVtCit2YWxncmlu ZF9zaG1lbV9zaG1fdG9jX2JnX2dldChQR19GVU5DVElPTl9BUkdTKQoreworCWludDMyCQlp bmRleCA9IFBHX0dFVEFSR19JTlQzMigwKTsKKwlzaG1fdG9jX2VzdGltYXRvciBlOworCVNp emUJCXNlZ3NpemU7CisJZHNtX3NlZ21lbnQgKnNlZzsKKwlzaG1fdG9jICAgICp0b2M7CisJ V29ya2VySGVhZGVyICpoZWFkZXI7CisJU2htZW1TdGF0ZSAqc3RhdGU7CisJQmFja2dyb3Vu ZFdvcmtlciB3b3JrZXIgPSB7CisJCS5iZ3dfZmxhZ3MgPSBCR1dPUktFUl9TSE1FTV9BQ0NF U1MsCisJCS5iZ3dfc3RhcnRfdGltZSA9IEJnV29ya2VyU3RhcnRfQ29uc2lzdGVudFN0YXRl LAorCQkuYmd3X3Jlc3RhcnRfdGltZSA9IEJHV19ORVZFUl9SRVNUQVJULAorCQkuYmd3X2xp YnJhcnlfbmFtZSA9ICJ2YWxncmluZF9zaG1lbSIsCisJCS5iZ3dfZnVuY3Rpb25fbmFtZSA9 ICJ2YWxncmluZF9zaG1lbV9tYWluIiwKKwkJLmJnd190eXBlID0gInZhbGdyaW5kX3NobWVt IiwKKwkJLmJnd19uYW1lID0gInZhbGdyaW5kX3NobWVtIHdvcmtlciIsCisJCS5iZ3dfbm90 aWZ5X3BpZCA9IE15UHJvY1BpZAorCX07CisJQmFja2dyb3VuZFdvcmtlckhhbmRsZSAqd2hh bmRsZTsKKwlpbnQzMgkJcmV0OworCisJc2htX3RvY19pbml0aWFsaXplX2VzdGltYXRvcigm ZSk7CisJc2htX3RvY19lc3RpbWF0ZV9jaHVuaygmZSwgc2l6ZW9mKFdvcmtlckhlYWRlcikp OworCXNobV90b2NfZXN0aW1hdGVfY2h1bmsoJmUsIHNpemVvZihTaG1lbVN0YXRlKSk7CisJ c2htX3RvY19lc3RpbWF0ZV9rZXlzKCZlLCAyKTsKKwlzZWdzaXplID0gc2htX3RvY19lc3Rp bWF0ZSgmZSk7CisKKwlzZWcgPSBkc21fY3JlYXRlKHNobV90b2NfZXN0aW1hdGUoJmUpLCAw KTsKKwl0b2MgPSBzaG1fdG9jX2NyZWF0ZShQR19URVNUX1ZBTEdSSU5EX1NITUVNX01BR0lD LCBkc21fc2VnbWVudF9hZGRyZXNzKHNlZyksIHNlZ3NpemUpOworCisJaGVhZGVyID0gc2ht X3RvY19hbGxvY2F0ZSh0b2MsIHNpemVvZihXb3JrZXJIZWFkZXIpKTsKKwloZWFkZXItPmlu ZGV4ID0gaW5kZXg7CisJaGVhZGVyLT5kb25lID0gZmFsc2U7CisJc2htX3RvY19pbnNlcnQo dG9jLCAwLCBoZWFkZXIpOworCisJc3RhdGUgPSBzaG1fdG9jX2FsbG9jYXRlKHRvYywgc2l6 ZW9mKFNobWVtU3RhdGUpKTsKKwlmb3IgKGludCBpID0gMDsgaSA8IDEwOyBpKyspCisJCXN0 YXRlLT5hW2ldID0gaSAqIDM7CisJc2htX3RvY19pbnNlcnQodG9jLCAxLCBzdGF0ZSk7CisK Kwl3b3JrZXIuYmd3X21haW5fYXJnID0gVUludDMyR2V0RGF0dW0oZHNtX3NlZ21lbnRfaGFu ZGxlKHNlZykpOworCisJaWYgKCFSZWdpc3RlckR5bmFtaWNCYWNrZ3JvdW5kV29ya2VyKCZ3 b3JrZXIsICZ3aGFuZGxlKSkKKwkJZXJlcG9ydChFUlJPUiwKKwkJCQllcnJjb2RlKEVSUkNP REVfSU5TVUZGSUNJRU5UX1JFU09VUkNFUyksCisJCQkJZXJybXNnKCJjb3VsZCBub3QgcmVn aXN0ZXIgYmFja2dyb3VuZCBwcm9jZXNzIiksCisJCQkJZXJyaGludCgiWW91IG1heSBuZWVk IHRvIGluY3JlYXNlIFwibWF4X3dvcmtlcl9wcm9jZXNzZXNcIi4iKSk7CisKKwlmb3IgKDs7 KQorCXsKKwkJQmd3SGFuZGxlU3RhdHVzIHN0YXR1czsKKwkJcGlkX3QJCXBpZDsKKworCQlp ZiAoaGVhZGVyLT5kb25lKQorCQkJYnJlYWs7CisKKwkJc3RhdHVzID0gR2V0QmFja2dyb3Vu ZFdvcmtlclBpZCh3aGFuZGxlLCAmcGlkKTsKKwkJaWYgKHN0YXR1cyA9PSBCR1dIX1NUT1BQ RUQgfHwgc3RhdHVzID09IEJHV0hfUE9TVE1BU1RFUl9ESUVEKQorCQkJZXJlcG9ydChFUlJP UiwKKwkJCQllcnJtc2coImJhY2tncm91bmQgd29ya2VyIGRpZWQgdW5leHBlY3RlZGx5Iikp OworCisJCWlmICh3ZV92YWxkZ3JpbmRfc2htZW1fcmVxdWVzdCA9PSAwKQorCQkJd2VfdmFs ZGdyaW5kX3NobWVtX3JlcXVlc3QgPSBXYWl0RXZlbnRFeHRlbnNpb25OZXcoIlRlc3RWYWxn cmluZEhzbWVtUmVxdWVzdCIpOworCisJCSh2b2lkKSBXYWl0TGF0Y2goTXlMYXRjaCwgV0xf TEFUQ0hfU0VUIHwgV0xfRVhJVF9PTl9QTV9ERUFUSCwgMCwKKwkJCQkJCSB3ZV92YWxkZ3Jp bmRfc2htZW1fcmVxdWVzdCk7CisKKwkJUmVzZXRMYXRjaChNeUxhdGNoKTsKKworCQlDSEVD S19GT1JfSU5URVJSVVBUUygpOworCX0KKworCXJldCA9IGhlYWRlci0+cmVzdWx0OworCisJ ZHNtX2RldGFjaChzZWcpOworCisJUEdfUkVUVVJOX0lOVDMyKHJldCk7Cit9CisKK3ZvaWQK K3ZhbGdyaW5kX3NobWVtX21haW4oRGF0dW0gbWFpbl9hcmcpCit7CisJZHNtX3NlZ21lbnQg KnNlZzsKKwlzaG1fdG9jICAgICp0b2M7CisJV29ya2VySGVhZGVyICpoZWFkZXI7CisJU2ht ZW1TdGF0ZSAqc3RhdGU7CisKKwlzZWcgPSBkc21fYXR0YWNoKERhdHVtR2V0VUludDMyKG1h aW5fYXJnKSk7CisJaWYgKHNlZyA9PSBOVUxMKQorCQllcmVwb3J0KEVSUk9SLAorCQkJCShl cnJjb2RlKEVSUkNPREVfT0JKRUNUX05PVF9JTl9QUkVSRVFVSVNJVEVfU1RBVEUpLAorCQkJ CSBlcnJtc2coInVuYWJsZSB0byBtYXAgZHluYW1pYyBzaGFyZWQgbWVtb3J5IHNlZ21lbnQi KSkpOworCisJdG9jID0gc2htX3RvY19hdHRhY2goUEdfVEVTVF9WQUxHUklORF9TSE1FTV9N QUdJQywgZHNtX3NlZ21lbnRfYWRkcmVzcyhzZWcpKTsKKwlpZiAodG9jID09IE5VTEwpCisJ CWVyZXBvcnQoRVJST1IsCisJCQkJKGVycmNvZGUoRVJSQ09ERV9PQkpFQ1RfTk9UX0lOX1BS RVJFUVVJU0lURV9TVEFURSksCisJCQkJIGVycm1zZygiYmFkIG1hZ2ljIG51bWJlciBpbiBk eW5hbWljIHNoYXJlZCBtZW1vcnkgc2VnbWVudCIpKSk7CisKKwloZWFkZXIgPSBzaG1fdG9j X2xvb2t1cCh0b2MsIDAsIGZhbHNlKTsKKwlzdGF0ZSA9IHNobV90b2NfbG9va3VwKHRvYywg MSwgZmFsc2UpOworCisJcGdfdXNsZWVwKDUwMCAqIDEwMDApOworCisJaGVhZGVyLT5yZXN1 bHQgPSBzdGF0ZS0+YVtoZWFkZXItPmluZGV4XTsKKwloZWFkZXItPmRvbmUgPSB0cnVlOwor CisJcHJvY19leGl0KDApOworfQorCit2b2lkCitfUEdfaW5pdCh2b2lkKQoreworCVJlZ2lz dGVyU2htZW1DYWxsYmFja3MoJnNobWVtX2NhbGxiYWNrcyk7Cit9CmRpZmYgLS1naXQgYS9j b250cmliL3ZhbGdyaW5kX3NobWVtL3ZhbGdyaW5kX3NobWVtLmNvbnRyb2wgYi9jb250cmli L3ZhbGdyaW5kX3NobWVtL3ZhbGdyaW5kX3NobWVtLmNvbnRyb2wKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmI3MGJkMGUyZDEwCi0tLSAvZGV2L251bGwKKysr IGIvY29udHJpYi92YWxncmluZF9zaG1lbS92YWxncmluZF9zaG1lbS5jb250cm9sCkBAIC0w LDAgKzEsNSBAQAorIyB2YWxpZ3JpbmRfc2htZW0gZXh0ZW5zaW9uCitjb21tZW50ID0gJ0R1 bW15IGV4dGVuc2lvbiB0ZXN0aW5nIHZhbGdyaW5kIGFuZCBzaGFyZWQgbWVtb3J5JworZGVm YXVsdF92ZXJzaW9uID0gJzEuMCcKK21vZHVsZV9wYXRobmFtZSA9ICckbGliZGlyL3ZhbGdy aW5kX3NobWVtJworcmVsb2NhdGFibGUgPSB0cnVlCi0tIAoyLjQzLjAKCg== --------------Kqnll0RAJonusX0P8WqI7VHg--