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 1whxsG-000VnU-2d for pgsql-hackers@arkaria.postgresql.org; Thu, 09 Jul 2026 23:09:45 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1whxsF-00F292-0u for pgsql-hackers@arkaria.postgresql.org; Thu, 09 Jul 2026 23:09:44 +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 1whxsE-00F28u-2e for pgsql-hackers@lists.postgresql.org; Thu, 09 Jul 2026 23:09:43 +0000 Received: from relay6-d.mail.gandi.net ([2001:4b98:dc4:8::226]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.98.2) (envelope-from ) id 1whxsC-00000000YfQ-1Zjm for pgsql-hackers@postgresql.org; Thu, 09 Jul 2026 23:09:43 +0000 Received: by mail.gandi.net (Postfix) with ESMTPSA id A95153E962; Thu, 9 Jul 2026 23:09:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=vondra.me; s=gm1; t=1783638574; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references; bh=mdy0sltwWdiALfP1ue1Mp4Kp5s8uytIJVP+wHbsZtyY=; b=A2hMyEILUgic/S3GHL0qwGKkSMv369J/+bVeSVGSzPFLMa210+zMNECN/g3D2YQ6wWHsz3 hrIhTEq/HXdlNdtG7Q+f848q1kvxvVIwCzwZEUBs17Ug1rIeeYJeFNp4rq7156szfcHviY eEJkeZEHhUHqLZ35Xxaqai7goOc6BxxuYVt6h6zQmVVPqZ/EPbSqc5bb9sohwPrjGEezjU kaIQx/sIAEBR2eWicmgqz87cMDbzGXM7bJXn/2khHT1jfRzn8iXKT5vriYqM49sJ7mw3QP sW1fTbNNEodHrCH8nOtN93OofccyvUEhWscNQlLcBGq26CcwHN054+P/BI2aHg== Content-Type: multipart/mixed; boundary="------------wUwsdYeUAvHnuly9PN1sjJLI" Message-ID: <7235642b-906c-4adc-bafe-51ea4afa2f20@vondra.me> Date: Fri, 10 Jul 2026 01:09:32 +0200 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: PoC: VALGRIND_MAKE_MEM_NOACCESS for dynamic shared memory To: Andreas Karlsson Cc: Andres Freund , pgsql-hackers References: <725d26a1-a604-4cf4-8cf4-3dfd532e2523@proxel.se> Content-Language: en-US From: Tomas Vondra In-Reply-To: <725d26a1-a604-4cf4-8cf4-3dfd532e2523@proxel.se> X-GND-Sasl: tomas@vondra.me X-GND-Cause: dmFkZTFBGLxnQ6wxMJS99UAWp+TaS+Va9UkQwpCfIeCeswxwyaLgBwrHq05Yf99xVrRRNodY4UsGbT74PRJSfortiF5FC4ZLKMJ5HdRb3w08TLPMOGBCew3+oCZTCvxQgh1aP8QeQ3uZX+uScayjSgNn4g0gYWvrGBc0skFcAUZc2HcNN1wS9QOaytqbf0atMDHTky6zDdyZ8U5mrNcsudhf9ggBWkQqAUk8H5DRdbOJ5+xooZFEXi7SY8kLV9CnJWyzrp3xtPPsd10CRXQ0ojAJPaEmRhQJv3bn+j60AZwrbm6aDbzUizNsCr339ZtCsYuB2gD7Ffb/Bz0UzjLaWFec1bl1cdxT4EQTmHOxGhNRROXwHpUttzuj9JpPhAw+VdMR5TTwn/2oCGU5ubACpsrG/HPEmFawmruLqnD0qb1OFiUzDY/IPHNnoLzc+L/NE7iAe3KnCT1sk5lQROH18hPCGJaDC5g0v4rbX/KImMM4JzY8GnolN3OYvB0aosBzlL3XNQrPRKJsTVvzVVTd6SNDJ7FcYFZr5agKIEu6zTp/M6dM96KuJdVf4+jFyCAor2mxRxuZ/5PLAUScFsfNgVsQrbsbEhDijMrhJ4DYM6BrTTG6Q5tzfYbMvEVsV/hUc8EMiq0GKKmLdPmFmO6Mxwmt2RL9sqPYXLZc/g7gYWb+/0II9w X-GND-State: clean X-GND-Score: -100 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. --------------wUwsdYeUAvHnuly9PN1sjJLI Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit On 7/8/26 02:31, Andreas Karlsson wrote: > 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. > Hmmm, I agree starting with everything marked as NOACCESS seems like a cleaner option, but if it doesn't work with EXEC_BACKEND (and if it can't be made to work) it's irrelevant. So what happens with EXEC_BACKEND builds? I see the 0002 patch now says: * When compiled with EXEC_BACKEND we need to recreate all NOACCESS * regions in each backend, but we can only recreate those with index * entries and not any of the regions for memory allocated directly with * ShmemAlloc(). Does it mean EXEC_BACKEND builds won't have any valgrind markings for the regions allocated by ShmemAlloc()? Or do I misunderstand? If that's the case, it seems EXEC_BACKEND builds would have limited checks no matter what. Maybe it'd make sense to use the "clean" approach for regular builds, and something simpler / limited for EXEC_BACKEND? It's a bit late over here, so maybe I'm missing something obvious, but it seems to me marking everything as NOACCESS (the "clean" approach) would catch even accesses this EXEC_BACKEND-compatible approach would not catch, right? That does not seem like a great trade off. > 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 don't see Andres mentioning shm_toc_lookup explicitly, but I guess it's what he meant when he mentioned NOACCESS and shm_toc_attach. Or did I miss an email in this thread? The dsm_detach business seems a bit strange to me. Can you explain why we need to clean the NOACCESS sentinels in dsm_detach (I understand why dsm_detach seems to be the only place to do that, but why do we need to)? And is DEFINED the right marking? I'd probably briefly explain that in the dsm_detach() comment. I mean, we're about to detach the memory, right? So why should it be accessible or defined? But if we need to do this stuff in dsm_detach(), maybe we could do something in dsm_attach() too? One comments about shm_toc_lookup - the new block says: /* * Since we do not know the size of entries we can only use the * start of the next entry for setting the no-access sentinel. */ Size nextoffset = i == 0 ? toc->toc_total_bytes : toc->toc_entry[i - 1].offset; That seems hard to read, without the "(i == 0)". More importantly, is it doing what the comment says? That talks about "next entry", but this looks at the previous entry, no? > 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. > Thanks. Seems useful for manual testing, but I agree it's not something we'd want to commit. > 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. > I'm not following. Why would new allocations (between shm_toc_attach and shm_toc_lookup) be an issue? > 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? > I suppose it's split into two functions because we don't want to add segments that are not fully initialized. The usual use case looks like this (this is from brin.c): sharedquery = (char *) shm_toc_allocate(pcxt->toc, querylen + 1); memcpy(sharedquery, debug_query_string, querylen + 1); shm_toc_insert(pcxt->toc, PARALLEL_KEY_QUERY_TEXT, sharedquery); If we added both attach+insert, we'd be adding empty string and only then set it. I suppose that'd not be safe in some cases? I don't think we'd want to merge these two functions into one, but I suppose we could add the length to shm_toc_insert(). Which I suppose simply wasn't needed until now. But I agree it'd not be great to do this just because of valgrind. There's a fair number of shm_toc_insert calls (~80), but not terrible. But we'd need to be careful to protect against shm_toc_insert calls with a different length value. I'm not sure what to do. I was thinking we might add a shm_toc length only in valgrind builds. And then we wouldn't need this NOACCESS_BYTES stuff at all. Bu I didn't realize we'd need to tweak shm_toc_insert. >>> 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. > Yeah. There was a minor bitrot due to b34fd845e03a, so here's v3. regards -- Tomas Vondra --------------wUwsdYeUAvHnuly9PN1sjJLI Content-Type: text/x-patch; charset=UTF-8; name="v3-0003-Toy-extension-to-make-it-easier-to-test-out-of-bo.patch" Content-Disposition: attachment; filename*0="v3-0003-Toy-extension-to-make-it-easier-to-test-out-of-bo.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSAyMjI2YzIzYmZlMWM3YTM1NTNiYjM0YjFjZTk1MzEzMDEwMWUzMzJhIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbmRyZWFzIEthcmxzc29uIDxhbmRyZWFzLmthcmxz c29uQHBlcmNvbmEuY29tPgpEYXRlOiBTYXQsIDQgSnVsIDIwMjYgMTM6MTc6MTUgKzAyMDAK U3ViamVjdDogW1BBVENIIHYzIDMvM10gVG95IGV4dGVuc2lvbiB0byBtYWtlIGl0IGVhc2ll 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 aW5kX3NobWVtJworcmVsb2NhdGFibGUgPSB0cnVlCi0tIAoyLjU0LjAKCg== --------------wUwsdYeUAvHnuly9PN1sjJLI Content-Type: text/x-patch; charset=UTF-8; name="v3-0002-valgrind-Add-NOACCESS-sentinels-to-allocations-in.patch" Content-Disposition: attachment; filename*0="v3-0002-valgrind-Add-NOACCESS-sentinels-to-allocations-in.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSBkOGM4OTY1NWVhZWI2YTM0ZTExNTcxNTUzYjRkMTEyYTUwZjFhMjk4IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbmRyZWFzIEthcmxzc29uIDxhbmRyZWFzLmthcmxz c29uQHBlcmNvbmEuY29tPgpEYXRlOiBUaHUsIDQgSnVuIDIwMjYgMTM6NTQ6MjIgKzAyMDAK U3ViamVjdDogW1BBVENIIHYzIDIvM10gdmFsZ3JpbmQ6IEFkZCBOT0FDQ0VTUyBzZW50aW5l bHMgdG8gYWxsb2NhdGlvbnMgaW4KIG1haW4gc2hhcmVkIG1lbW9yeQoKV2hlbiBidWlsdCB3 aXRoIFVTRV9WQUxHUklORCB3ZSBoYXZlIHRoZSBTaG1lbUFsbG9jYXRvciBhZGQgYSBOT0FD Q0VTUwpzZW50aW5lbCBhZnRlciBldmVyeSBhbGxvY2F0aW9uIGluIHNoYXJlZCBtZW1vcnku IE9uIEVYRUNfQkFDS0VORCBidWlsZHMKd2Ugc2V0IHVwIHRoZSBzZW50aW5lbHMgd2hlbiB0 aGUgYmFja2VuZCBhdHRhY2hlcyB0byBzaGFyZWQgbWVtb3J5LCBidXQKdGhlbiBvbmx5IGZv ciB0aGluZ3MgaW4gU2htZW1JbmRleCBhbmQgbm90IGZvciBhbGxvY2F0aW9ucyBkb25lIGRp cmVjdGx5CnZpYSBsZWdhY3kgZnVuY3Rpb25zIGxpa2UgU2htZW1BbGxvYygpLgoKQXV0aG9y OiBBbmRyZWFzIEthcmxzc29uIDxhbmRyZWFzQHByb3hlbC5zZT4KLS0tCiBzcmMvYmFja2Vu ZC9zdG9yYWdlL2lwYy9zaG1lbS5jIHwgMzggKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKystCiAxIGZpbGUgY2hhbmdlZCwgMzcgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigt KQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvaXBjL3NobWVtLmMgYi9zcmMv YmFja2VuZC9zdG9yYWdlL2lwYy9zaG1lbS5jCmluZGV4IDFmYmJhOWMzYTRjLi4yNWE2YTdl Yzg5OSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9pcGMvc2htZW0uYworKysg 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 CiAJfQogCWVsc2UKIAkJbmV3U3BhY2UgPSBOVUxMOwotLSAKMi41NC4wCgo= --------------wUwsdYeUAvHnuly9PN1sjJLI Content-Type: text/x-patch; charset=UTF-8; name="v3-0001-valgrind-Add-NOACCESS-sentinels-for-shm_toc-entri.patch" Content-Disposition: attachment; filename*0="v3-0001-valgrind-Add-NOACCESS-sentinels-for-shm_toc-entri.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSA3MWUwNjI0Y2VjMDViOGU4ODM1YjI4ZjNkYmQ1OGE4YWEyODk2ZjQxIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb21hcyBWb25kcmEgPHRvbWFzQHZvbmRyYS5tZT4K RGF0ZTogU2F0LCAyIE1heSAyMDI2IDIzOjA5OjAwICswMjAwClN1YmplY3Q6IFtQQVRDSCB2 MyAxLzNdIHZhbGdyaW5kOiBBZGQgTk9BQ0NFU1Mgc2VudGluZWxzIGZvciBzaG1fdG9jIGVu 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 bmRleCAyMjE3ZDQ4YzNkOS4uMDE1N2Y1YzU4NmMgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5k L3N0b3JhZ2UvaXBjL3NobV90b2MuYworKysgYi9zcmMvYmFja2VuZC9zdG9yYWdlL2lwYy9z aG1fdG9jLmMKQEAgLTE2LDYgKzE2LDcgQEAKICNpbmNsdWRlICJwb3J0L2F0b21pY3MuaCIK ICNpbmNsdWRlICJzdG9yYWdlL3NobV90b2MuaCIKICNpbmNsdWRlICJzdG9yYWdlL3NwaW4u aCIKKyNpbmNsdWRlICJ1dGlscy9tZW1kZWJ1Zy5oIgogCiB0eXBlZGVmIHN0cnVjdCBzaG1f dG9jX2VudHJ5CiB7CkBAIC03NCw2ICs3NSwxMyBAQCBzaG1fdG9jX2F0dGFjaCh1aW50NjQg bWFnaWMsIHZvaWQgKmFkZHJlc3MpCiAJcmV0dXJuIHRvYzsKIH0KIAorLyogV2l0aCB2YWxn cmluZCwgd2Ugd2FudCB0byBhZGQgYSBjb3VwbGUgTk9BQ0NFU1MgYnl0ZXMgKi8KKyNpZmRl ZiBVU0VfVkFMR1JJTkQKKyNkZWZpbmUgTlVNX05PQUNDRVNTX0JZVEVTIDMyCisjZWxzZQor I2RlZmluZSBOVU1fTk9BQ0NFU1NfQllURVMgMAorI2VuZGlmCisKIC8qCiAgKiBBbGxvY2F0 ZSBzaGFyZWQgbWVtb3J5IGZyb20gYSBzZWdtZW50IG1hbmFnZWQgYnkgYSB0YWJsZSBvZiBj b250ZW50cy4KICAqCkBAIC04Nyw2ICs5NSw3IEBAIHNobV90b2NfYXR0YWNoKHVpbnQ2NCBt YWdpYywgdm9pZCAqYWRkcmVzcykKIHZvaWQgKgogc2htX3RvY19hbGxvY2F0ZShzaG1fdG9j ICp0b2MsIFNpemUgbmJ5dGVzKQogeworCVNpemUJCXJlcWJ5dGVzOwogCVNpemUJCXRvdGFs X2J5dGVzOwogCVNpemUJCWFsbG9jYXRlZF9ieXRlczsKIAlTaXplCQluZW50cnk7CkBAIC05 OCw3ICsxMDcsNyBAQCBzaG1fdG9jX2FsbG9jYXRlKHNobV90b2MgKnRvYywgU2l6ZSBuYnl0 ZXMpCiAJICogcHJvcGVyIGRlZmluaXRpb24gZm9yIHRoZSBtaW5pbXVtIHRvIG1ha2UgYXRv bWljIG9wcyBzYWZlLCBidXQKIAkgKiBCVUZGRVJBTElHTiBvdWdodCB0byBiZSBlbm91Z2gu CiAJICovCi0JbmJ5dGVzID0gQlVGRkVSQUxJR04obmJ5dGVzKTsKKwlyZXFieXRlcyA9IEJV RkZFUkFMSUdOKG5ieXRlcyArIE5VTV9OT0FDQ0VTU19CWVRFUyk7CiAKIAlTcGluTG9ja0Fj cXVpcmUoJnRvYy0+dG9jX211dGV4KTsKIApAQCAtMTA5LDE4ICsxMTgsMjQgQEAgc2htX3Rv Y19hbGxvY2F0ZShzaG1fdG9jICp0b2MsIFNpemUgbmJ5dGVzKQogCQkrIGFsbG9jYXRlZF9i eXRlczsKIAogCS8qIENoZWNrIGZvciBtZW1vcnkgZXhoYXVzdGlvbiBhbmQgb3ZlcmZsb3cu ICovCi0JaWYgKHRvY19ieXRlcyArIG5ieXRlcyA+IHRvdGFsX2J5dGVzIHx8IHRvY19ieXRl cyArIG5ieXRlcyA8IHRvY19ieXRlcykKKwlpZiAodG9jX2J5dGVzICsgcmVxYnl0ZXMgPiB0 b3RhbF9ieXRlcyB8fCB0b2NfYnl0ZXMgKyByZXFieXRlcyA8IHRvY19ieXRlcykKIAl7CiAJ CVNwaW5Mb2NrUmVsZWFzZSgmdG9jLT50b2NfbXV0ZXgpOwogCQllcmVwb3J0KEVSUk9SLAog CQkJCShlcnJjb2RlKEVSUkNPREVfT1VUX09GX01FTU9SWSksCiAJCQkJIGVycm1zZygib3V0 IG9mIHNoYXJlZCBtZW1vcnkiKSkpOwogCX0KLQl0b2MtPnRvY19hbGxvY2F0ZWRfYnl0ZXMg Kz0gbmJ5dGVzOworCXRvYy0+dG9jX2FsbG9jYXRlZF9ieXRlcyArPSByZXFieXRlczsKIAog CVNwaW5Mb2NrUmVsZWFzZSgmdG9jLT50b2NfbXV0ZXgpOwogCi0JcmV0dXJuICgoY2hhciAq KSB0b2MpICsgKHRvdGFsX2J5dGVzIC0gYWxsb2NhdGVkX2J5dGVzIC0gbmJ5dGVzKTsKKyNp ZmRlZiBVU0VfVkFMR1JJTkQKKwkvKiBNYWtlIHRoZSBieXRlcyBhdCB0aGUgZW5kIG5vLWFj Y2VzcyAqLworCVZBTEdSSU5EX01BS0VfTUVNX05PQUNDRVNTKCgoY2hhciAqKSB0b2MpICsg KHRvdGFsX2J5dGVzIC0gYWxsb2NhdGVkX2J5dGVzIC0gcmVxYnl0ZXMgKyBuYnl0ZXMpLAor CQkJCQkJCSAgIHJlcWJ5dGVzIC0gbmJ5dGVzKTsKKyNlbmRpZgorCisJcmV0dXJuICgoY2hh ciAqKSB0b2MpICsgKHRvdGFsX2J5dGVzIC0gYWxsb2NhdGVkX2J5dGVzIC0gcmVxYnl0ZXMp OwogfQogCiAvKgpAQCAtMjQ5LDcgKzI2NCwyMCBAQCBzaG1fdG9jX2xvb2t1cChzaG1fdG9j ICp0b2MsIHVpbnQ2NCBrZXksIGJvb2wgbm9FcnJvcikKIAlmb3IgKGkgPSAwOyBpIDwgbmVu dHJ5OyArK2kpCiAJewogCQlpZiAodG9jLT50b2NfZW50cnlbaV0ua2V5ID09IGtleSkKKwkJ eworI2lmZGVmIFVTRV9WQUxHUklORAorCQkJLyoKKwkJCSAqIFNpbmNlIHdlIGRvIG5vdCBr bm93IHRoZSBzaXplIG9mIGVudHJpZXMgd2UgY2FuIG9ubHkgdXNlIHRoZQorCQkJICogc3Rh cnQgb2YgdGhlIG5leHQgZW50cnkgZm9yIHNldHRpbmcgdGhlIG5vLWFjY2VzcyBzZW50aW5l bC4KKwkJCSAqLworCQkJU2l6ZQkJbmV4dG9mZnNldCA9IGkgPT0gMCA/IHRvYy0+dG9jX3Rv dGFsX2J5dGVzIDogdG9jLT50b2NfZW50cnlbaSAtIDFdLm9mZnNldDsKKworCQkJVkFMR1JJ TkRfTUFLRV9NRU1fTk9BQ0NFU1MoKChjaGFyICopIHRvYykgKyBuZXh0b2Zmc2V0IC0gTlVN X05PQUNDRVNTX0JZVEVTLAorCQkJCQkJCQkJCU5VTV9OT0FDQ0VTU19CWVRFUyk7CisjZW5k aWYKKwogCQkJcmV0dXJuICgoY2hhciAqKSB0b2MpICsgdG9jLT50b2NfZW50cnlbaV0ub2Zm c2V0OworCQl9CiAJfQogCiAJLyogTm8gbWF0Y2hpbmcgZW50cnkgd2FzIGZvdW5kLiAqLwpA QCAtMjcyLDUgKzMwMCw4IEBAIHNobV90b2NfZXN0aW1hdGUoc2htX3RvY19lc3RpbWF0b3Ig KmUpCiAJc3ogPSBhZGRfc2l6ZShzeiwgbXVsX3NpemUoZS0+bnVtYmVyX29mX2tleXMsIHNp emVvZihzaG1fdG9jX2VudHJ5KSkpOwogCXN6ID0gYWRkX3NpemUoc3osIGUtPnNwYWNlX2Zv cl9jaHVua3MpOwogCisJLyogYWRkIHNwYWNlIGZvciBFTk9BQ0NFU1MgYnl0ZXMsIE5VTV9O T0FDQ0VTU19CWVRFUyBwZXIga2V5ICovCisJc3ogPSBhZGRfc2l6ZShzeiwgbXVsX3NpemUo ZS0+bnVtYmVyX29mX2tleXMsIE5VTV9OT0FDQ0VTU19CWVRFUykpOworCiAJcmV0dXJuIEJV RkZFUkFMSUdOKHN6KTsKIH0KLS0gCjIuNTQuMAoK --------------wUwsdYeUAvHnuly9PN1sjJLI--