Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1rkn2b-00FOUs-To for pgsql-hackers@arkaria.postgresql.org; Thu, 14 Mar 2024 15:30:47 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.94.2) (envelope-from ) id 1rkn2a-0012R9-7E for pgsql-hackers@arkaria.postgresql.org; Thu, 14 Mar 2024 15:30:44 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1rkn2Z-0012R1-HE for pgsql-hackers@lists.postgresql.org; Thu, 14 Mar 2024 15:30:44 +0000 Received: from meesny.iki.fi ([195.140.195.201]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1rkn2Q-004UG4-Bb for pgsql-hackers@lists.postgresql.org; Thu, 14 Mar 2024 15:30:42 +0000 Received: from [192.168.1.115] (dsl-hkibng22-54f8db-125.dhcp.inet.fi [84.248.219.125]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: hlinnaka) by meesny.iki.fi (Postfix) with ESMTPSA id 4TwWY270yfzyPB; Thu, 14 Mar 2024 17:30:30 +0200 (EET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=iki.fi; s=meesny; t=1710430231; 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=0rqCdBvMxtdk7dnpgshfewfgQvPybva7OZOvZuJXFts=; b=btPrUppI2fKChR90DsCQeiXIwOfrOrVAzkRuh1/nJ5kh/afORHOxzCCVZxb56PRW3M/0BM 8Iy2Tpy1bLIrAV3Oj16CwE0tgPzLyZzvr+djoPU0Wdo1xjFGnrFP6BdYSw339kccLx1xgb fGlUzi1/HNU+QAuHhbxacq3vO2y3eyo= ARC-Seal: i=1; s=meesny; d=iki.fi; t=1710430231; a=rsa-sha256; cv=none; b=nDrM3XP12sz0pO1PoH/Yt7dlETDxna8+YvkDsD4i6ioaMLF5cyzlQX7uXSvyHq8aQzs/Uo EHlZEfNfX8mLutOywjGnYJOAAnWdeXnMf3tHc7bSYyGvOvCUYp6IgQfrLmukplLSIG20y9 a9jL2+XuGKKH0hUVYgoEoFmvtB8E8/Y= ARC-Authentication-Results: i=1; ORIGINATING; auth=pass smtp.auth=hlinnaka smtp.mailfrom=hlinnaka@iki.fi ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=iki.fi; s=meesny; t=1710430231; 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=0rqCdBvMxtdk7dnpgshfewfgQvPybva7OZOvZuJXFts=; b=wk0CFPrH6o/w27Uop/+omqdHwFfq4xlKXt5APM1D+gwT9iZ/kECQv6lHyPCMH0nSYdPFoz 45V8Ga5i900rFSgbpo0rTz+N3ef7JEkAqj7Na8d28kt9rR3HENu2ympXhuvWTxunyq33WG B/FoXH6cX0a2G3Y0+WV7fDRIZKXAN3Q= Content-Type: multipart/mixed; boundary="------------FT3HFu113HfSiGVwZLhSHeHk" Message-ID: Date: Thu, 14 Mar 2024 17:30:30 +0200 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: Parallel Bitmap Heap Scan reports per-worker stats in EXPLAIN ANALYZE Content-Language: en-US To: Tomas Vondra , Dilip Kumar , David Geier Cc: PostgreSQL Developers , Melanie Plageman References: From: Heikki Linnakangas 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. --------------FT3HFu113HfSiGVwZLhSHeHk Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit On 18/02/2024 00:31, Tomas Vondra wrote: > Do you plan to work continue working on this patch? I did take a look, > and on the whole it looks reasonable - it modifies the right places etc. +1 > I think there are two things that may need an improvement: > > 1) Storing variable-length data in ParallelBitmapHeapState > > I agree with Robert the snapshot_and_stats name is not great. I see > Dmitry mentioned phs_snapshot_off as used by ParallelTableScanDescData - > the reasons are somewhat different (phs_snapshot_off exists because we > don't know which exact struct will be allocated), while here we simply > need to allocate two variable-length pieces of memory. But it seems like > it would work nicely for this. That is, we could try adding an offset > for each of those pieces of memory: > > - snapshot_off > - stats_off > > I don't like the GetSharedSnapshotData name very much, it seems very > close to GetSnapshotData - quite confusing, I think. > > Dmitry also suggested we might add a separate piece of shared memory. I > don't quite see how that would work for ParallelBitmapHeapState, but I > doubt it'd be simpler than having two offsets. I don't think the extra > complexity (paid by everyone) would be worth it just to make EXPLAIN > ANALYZE work. I just removed phs_snapshot_data in commit 84c18acaf6. I thought that would make this moot, but now that I rebased this, there are stills some aesthetic questions on how best to represent this. In all the other node types that use shared instrumentation like this, the pattern is as follows: (using Memoize here as an example, but it's similar for Sort, IncrementalSort, Agg and Hash) /* ---------------- * Shared memory container for per-worker memoize information * ---------------- */ typedef struct SharedMemoizeInfo { int num_workers; MemoizeInstrumentation sinstrument[FLEXIBLE_ARRAY_MEMBER]; } SharedMemoizeInfo; /* this struct is backend-private */ typedef struct MemoizeState { ScanState ss; /* its first field is NodeTag */ ... MemoizeInstrumentation stats; /* execution statistics */ SharedMemoizeInfo *shared_info; /* statistics for parallel workers */ } MemoizeState; While the scan is running, the node updates its private data in MemoizeState->stats. At the end of a parallel scan, the worker process copies the MemoizeState->stats to MemoizeState->shared_info->stats, which lives in shared memory. The leader process copies MemoizeState->shared_info->stats to its own backend-private copy, which it then stores in its MemoizeState->shared_info, replacing the pointer to the shared memory with a pointer to the private copy. That happens in ExecMemoizeRetrieveInstrumentation(). This is a little different for parallel bitmap heap scans, because a bitmap heap scan keeps some other data in shared memory too, not just instrumentation data. Also, the naming is inconsistent: the equivalent of SharedMemoizeInfo is actually called ParallelBitmapHeapState. I think we should rename it to SharedBitmapHeapInfo, to make it clear that it lives in shared memory, but I digress. We could now put the new stats at the end of ParallelBitmapHeapState as a varlen field. But I'm not sure that's a good idea. In ExecBitmapHeapRetrieveInstrumentation(), would we make a backend-private copy of the whole ParallelBitmapHeapState struct, even though the other fields don't make sense after the shared memory is released? Sounds confusing. Or we could introduce a separate struct for the stats, and copy just that: typedef struct SharedBitmapHeapInstrumentation { int num_workers; BitmapHeapScanInstrumentation sinstrument[FLEXIBLE_ARRAY_MEMBER]; } SharedBitmapHeapInstrumentation; typedef struct BitmapHeapScanState { ScanState ss; /* its first field is NodeTag */ ... SharedBitmapHeapInstrumentation sinstrument; } BitmapHeapScanState; that compiles, at least with my compiler, but I find it weird to have a variable-length inner struct embedded in an outer struct like that. Long story short, I think it's still better to store ParallelBitmapHeapInstrumentationInfo separately in the DSM chunk, not as part of ParallelBitmapHeapState. Attached patch does that, rebased over current master. I didn't address any of the other things that you, Tomas, pointed out, but I think they're valid concerns. -- Heikki Linnakangas Neon (https://neon.tech) --------------FT3HFu113HfSiGVwZLhSHeHk Content-Type: text/x-patch; charset=UTF-8; name="v3-0001-Parallel-Bitmap-Heap-Scan-reports-per-worker-stat.patch" Content-Disposition: attachment; filename*0="v3-0001-Parallel-Bitmap-Heap-Scan-reports-per-worker-stat.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSAwNGYxMWEzN2VlMDRiMjgyYzUxZTlkYWU2OGVhZDdjOWMzZDVmYjNkIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBEYXZpZCBHZWllciA8Z2VpZGF2LnBnQGdtYWlsLmNv bT4KRGF0ZTogVHVlLCA4IE5vdiAyMDIyIDE5OjQwOjMxICswMTAwClN1YmplY3Q6IFtQQVRD SCB2MyAxLzFdIFBhcmFsbGVsIEJpdG1hcCBIZWFwIFNjYW4gcmVwb3J0cyBwZXItd29ya2Vy IHN0YXRzCgpTaW1pbGFybHkgdG8gb3RoZXIgbm9kZXMgKGUuZy4gaGFzaCBqb2luLCBzb3J0 LCBtZW1vaXplKSwKQml0bWFwIEhlYXAgU2NhbiBub3cgcmVwb3J0cyBwZXItd29ya2VyIHN0 YXRzIGluIHRoZSBFWFBMQUlOCkFOQUxZWkUgb3V0cHV0LiBQcmV2aW91c2x5IG9ubHkgdGhl IGhlYXAgYmxvY2tzIHN0YXRzIGZvciB0aGUKbGVhZGVyIHdlcmUgcmVwb3J0ZWQgd2hpY2gg d2FzIGluY29tcGxldGUgaW4gcGFyYWxsZWwgc2NhbnMuCgpEaXNjdXNzaW9uOiBodHRwczov L3d3dy5wb3N0Z3Jlc3FsLm9yZy9tZXNzYWdlLWlkL2ZsYXQvYjNkODA5NjEtYzJlNS0zOGNj LTZhMzItNjE4ODZjZGY3NjZkJTQwZ21haWwuY29tCi0tLQogc3JjL2JhY2tlbmQvY29tbWFu ZHMvZXhwbGFpbi5jICAgICAgICAgICAgfCA0NSArKysrKysrKystLQogc3JjL2JhY2tlbmQv ZXhlY3V0b3IvZXhlY1BhcmFsbGVsLmMgICAgICAgfCAgMyArCiBzcmMvYmFja2VuZC9leGVj dXRvci9ub2RlQml0bWFwSGVhcHNjYW4uYyB8IDkzICsrKysrKysrKysrKysrKysrKysrLS0t CiBzcmMvaW5jbHVkZS9leGVjdXRvci9ub2RlQml0bWFwSGVhcHNjYW4uaCB8ICAxICsKIHNy Yy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rlcy5oICAgICAgICAgICAgIHwgMzMgKysrKysrKy0K IDUgZmlsZXMgY2hhbmdlZCwgMTU3IGluc2VydGlvbnMoKyksIDE4IGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2V4cGxhaW4uYyBiL3NyYy9iYWNr ZW5kL2NvbW1hbmRzL2V4cGxhaW4uYwppbmRleCBhOWQ1MDU2YWY0OC4uNGMxYzFiZjYyNjgg MTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2V4cGxhaW4uYworKysgYi9zcmMv YmFja2VuZC9jb21tYW5kcy9leHBsYWluLmMKQEAgLTM0NzYsMjYgKzM0NzYsNTcgQEAgc2hv d19oYXNoYWdnX2luZm8oQWdnU3RhdGUgKmFnZ3N0YXRlLCBFeHBsYWluU3RhdGUgKmVzKQog c3RhdGljIHZvaWQKIHNob3dfdGlkYml0bWFwX2luZm8oQml0bWFwSGVhcFNjYW5TdGF0ZSAq cGxhbnN0YXRlLCBFeHBsYWluU3RhdGUgKmVzKQogeworCUFzc2VydChlcy0+YW5hbHl6ZSk7 CisKIAlpZiAoZXMtPmZvcm1hdCAhPSBFWFBMQUlOX0ZPUk1BVF9URVhUKQogCXsKIAkJRXhw bGFpblByb3BlcnR5SW50ZWdlcigiRXhhY3QgSGVhcCBCbG9ja3MiLCBOVUxMLAotCQkJCQkJ CSAgIHBsYW5zdGF0ZS0+ZXhhY3RfcGFnZXMsIGVzKTsKKwkJCQkJCQkgICBwbGFuc3RhdGUt PnN0YXRzLmV4YWN0X3BhZ2VzLCBlcyk7CiAJCUV4cGxhaW5Qcm9wZXJ0eUludGVnZXIoIkxv c3N5IEhlYXAgQmxvY2tzIiwgTlVMTCwKLQkJCQkJCQkgICBwbGFuc3RhdGUtPmxvc3N5X3Bh Z2VzLCBlcyk7CisJCQkJCQkJICAgcGxhbnN0YXRlLT5zdGF0cy5sb3NzeV9wYWdlcywgZXMp OwogCX0KIAllbHNlCiAJewotCQlpZiAocGxhbnN0YXRlLT5leGFjdF9wYWdlcyA+IDAgfHwg cGxhbnN0YXRlLT5sb3NzeV9wYWdlcyA+IDApCisJCWlmIChwbGFuc3RhdGUtPnN0YXRzLmV4 YWN0X3BhZ2VzID4gMCB8fCBwbGFuc3RhdGUtPnN0YXRzLmxvc3N5X3BhZ2VzID4gMCkKIAkJ ewogCQkJRXhwbGFpbkluZGVudFRleHQoZXMpOwogCQkJYXBwZW5kU3RyaW5nSW5mb1N0cmlu Zyhlcy0+c3RyLCAiSGVhcCBCbG9ja3M6Iik7Ci0JCQlpZiAocGxhbnN0YXRlLT5leGFjdF9w YWdlcyA+IDApCi0JCQkJYXBwZW5kU3RyaW5nSW5mbyhlcy0+c3RyLCAiIGV4YWN0PSVsZCIs IHBsYW5zdGF0ZS0+ZXhhY3RfcGFnZXMpOwotCQkJaWYgKHBsYW5zdGF0ZS0+bG9zc3lfcGFn ZXMgPiAwKQotCQkJCWFwcGVuZFN0cmluZ0luZm8oZXMtPnN0ciwgIiBsb3NzeT0lbGQiLCBw bGFuc3RhdGUtPmxvc3N5X3BhZ2VzKTsKKwkJCWlmIChwbGFuc3RhdGUtPnN0YXRzLmV4YWN0 X3BhZ2VzID4gMCkKKwkJCQlhcHBlbmRTdHJpbmdJbmZvKGVzLT5zdHIsICIgZXhhY3Q9JWxk IiwgcGxhbnN0YXRlLT5zdGF0cy5leGFjdF9wYWdlcyk7CisJCQlpZiAocGxhbnN0YXRlLT5z dGF0cy5sb3NzeV9wYWdlcyA+IDApCisJCQkJYXBwZW5kU3RyaW5nSW5mbyhlcy0+c3RyLCAi IGxvc3N5PSVsZCIsIHBsYW5zdGF0ZS0+c3RhdHMubG9zc3lfcGFnZXMpOwogCQkJYXBwZW5k U3RyaW5nSW5mb0NoYXIoZXMtPnN0ciwgJ1xuJyk7CiAJCX0KIAl9CisKKwlpZiAocGxhbnN0 YXRlLT5wc3RhdGUgIT0gTlVMTCkKKwl7CisJCWZvciAoaW50IG4gPSAwOyBuIDwgcGxhbnN0 YXRlLT5zaW5zdHJ1bWVudC0+bnVtX3dvcmtlcnM7IG4rKykKKwkJeworCQkJQml0bWFwSGVh cFNjYW5JbnN0cnVtZW50YXRpb24gKnNpID0gJnBsYW5zdGF0ZS0+c2luc3RydW1lbnQtPnNp bnN0cnVtZW50W25dOworCisJCQlpZiAoc2ktPmV4YWN0X3BhZ2VzID09IDAgJiYgc2ktPmxv c3N5X3BhZ2VzID09IDApCisJCQkJY29udGludWU7CisKKwkJCWlmIChlcy0+d29ya2Vyc19z dGF0ZSkKKwkJCQlFeHBsYWluT3BlbldvcmtlcihuLCBlcyk7CisKKwkJCWlmIChlcy0+Zm9y bWF0ID09IEVYUExBSU5fRk9STUFUX1RFWFQpCisJCQl7CisJCQkJRXhwbGFpbkluZGVudFRl eHQoZXMpOworCQkJCWFwcGVuZFN0cmluZ0luZm8oZXMtPnN0ciwgIkhlYXAgQmxvY2tzOiBl eGFjdD0lbGQgbG9zc3k9JWxkXG4iLAorCQkJCQkJIHNpLT5leGFjdF9wYWdlcywgc2ktPmxv c3N5X3BhZ2VzKTsKKwkJCX0KKwkJCWVsc2UKKwkJCXsKKwkJCQlFeHBsYWluUHJvcGVydHlJ bnRlZ2VyKCJFeGFjdCBIZWFwIEJsb2NrcyIsIE5VTEwsIHNpLT5leGFjdF9wYWdlcywgZXMp OworCQkJCUV4cGxhaW5Qcm9wZXJ0eUludGVnZXIoIkxvc3N5IEhlYXAgQmxvY2tzIiwgTlVM TCwgc2ktPmxvc3N5X3BhZ2VzLCBlcyk7CisJCQl9CisKKwkJCWlmIChlcy0+d29ya2Vyc19z dGF0ZSkKKwkJCQlFeHBsYWluQ2xvc2VXb3JrZXIobiwgZXMpOworCQl9CisJfQogfQogCiAv KgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1BhcmFsbGVsLmMgYi9z cmMvYmFja2VuZC9leGVjdXRvci9leGVjUGFyYWxsZWwuYwppbmRleCA4YzUzZDE4MzRlOS4u YmZiMzQxOWVmYjcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNQYXJh bGxlbC5jCisrKyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNQYXJhbGxlbC5jCkBAIC0x MDc2LDYgKzEwNzYsOSBAQCBFeGVjUGFyYWxsZWxSZXRyaWV2ZUluc3RydW1lbnRhdGlvbihQ bGFuU3RhdGUgKnBsYW5zdGF0ZSwKIAkJY2FzZSBUX01lbW9pemVTdGF0ZToKIAkJCUV4ZWNN ZW1vaXplUmV0cmlldmVJbnN0cnVtZW50YXRpb24oKE1lbW9pemVTdGF0ZSAqKSBwbGFuc3Rh dGUpOwogCQkJYnJlYWs7CisJCWNhc2UgVF9CaXRtYXBIZWFwU2NhblN0YXRlOgorCQkJRXhl Y0JpdG1hcEhlYXBSZXRyaWV2ZUluc3RydW1lbnRhdGlvbigoQml0bWFwSGVhcFNjYW5TdGF0 ZSAqKSBwbGFuc3RhdGUpOworCQkJYnJlYWs7CiAJCWRlZmF1bHQ6CiAJCQlicmVhazsKIAl9 CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlQml0bWFwSGVhcHNjYW4u YyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVCaXRtYXBIZWFwc2Nhbi5jCmluZGV4IGNh NTQ4ZTQ0ZWI0Li40NWRlMjYxZTJmYSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0 b3Ivbm9kZUJpdG1hcEhlYXBzY2FuLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9k ZUJpdG1hcEhlYXBzY2FuLmMKQEAgLTIzNiw5ICsyMzYsOSBAQCBCaXRtYXBIZWFwTmV4dChC aXRtYXBIZWFwU2NhblN0YXRlICpub2RlKQogCQkJfQogCiAJCQlpZiAodGJtcmVzLT5udHVw bGVzID49IDApCi0JCQkJbm9kZS0+ZXhhY3RfcGFnZXMrKzsKKwkJCQlub2RlLT5zdGF0cy5l eGFjdF9wYWdlcysrOwogCQkJZWxzZQotCQkJCW5vZGUtPmxvc3N5X3BhZ2VzKys7CisJCQkJ bm9kZS0+c3RhdHMubG9zc3lfcGFnZXMrKzsKIAogCQkJLyogQWRqdXN0IHRoZSBwcmVmZXRj aCB0YXJnZXQgKi8KIAkJCUJpdG1hcEFkanVzdFByZWZldGNoVGFyZ2V0KG5vZGUpOwpAQCAt NjQ3LDYgKzY0NywxNyBAQCBFeGVjRW5kQml0bWFwSGVhcFNjYW4oQml0bWFwSGVhcFNjYW5T dGF0ZSAqbm9kZSkKIHsKIAlUYWJsZVNjYW5EZXNjIHNjYW5EZXNjOwogCisJLyoKKwkgKiBX aGVuIGVuZGluZyBhIHBhcmFsbGVsIHdvcmtlciwgY29weSB0aGUgc3RhdGlzdGljcyBnYXRo ZXJlZCBieSB0aGUKKwkgKiB3b3JrZXIgYmFjayBpbnRvIHNoYXJlZCBtZW1vcnkgc28gdGhh dCBpdCBjYW4gYmUgcGlja2VkIHVwIGJ5IHRoZSBtYWluCisJICogcHJvY2VzcyB0byByZXBv cnQgaW4gRVhQTEFJTiBBTkFMWVpFLgorCSAqLworCWlmIChub2RlLT5zaW5zdHJ1bWVudCAh PSBOVUxMICYmIElzUGFyYWxsZWxXb3JrZXIoKSkKKwl7CisJCUFzc2VydChQYXJhbGxlbFdv cmtlck51bWJlciA8PSBub2RlLT5zaW5zdHJ1bWVudC0+bnVtX3dvcmtlcnMpOworCQlub2Rl LT5zaW5zdHJ1bWVudC0+c2luc3RydW1lbnRbUGFyYWxsZWxXb3JrZXJOdW1iZXJdID0gbm9k ZS0+c3RhdHM7CisJfQorCiAJLyoKIAkgKiBleHRyYWN0IGluZm9ybWF0aW9uIGZyb20gdGhl IG5vZGUKIAkgKi8KQEAgLTcxNiw4ICs3MjcsOCBAQCBFeGVjSW5pdEJpdG1hcEhlYXBTY2Fu KEJpdG1hcEhlYXBTY2FuICpub2RlLCBFU3RhdGUgKmVzdGF0ZSwgaW50IGVmbGFncykKIAlz Y2Fuc3RhdGUtPnJldHVybl9lbXB0eV90dXBsZXMgPSAwOwogCXNjYW5zdGF0ZS0+dm1idWZm ZXIgPSBJbnZhbGlkQnVmZmVyOwogCXNjYW5zdGF0ZS0+cHZtYnVmZmVyID0gSW52YWxpZEJ1 ZmZlcjsKLQlzY2Fuc3RhdGUtPmV4YWN0X3BhZ2VzID0gMDsKLQlzY2Fuc3RhdGUtPmxvc3N5 X3BhZ2VzID0gMDsKKwlzY2Fuc3RhdGUtPnN0YXRzLmV4YWN0X3BhZ2VzID0gMDsKKwlzY2Fu c3RhdGUtPnN0YXRzLmxvc3N5X3BhZ2VzID0gMDsKIAlzY2Fuc3RhdGUtPnByZWZldGNoX2l0 ZXJhdG9yID0gTlVMTDsKIAlzY2Fuc3RhdGUtPnByZWZldGNoX3BhZ2VzID0gMDsKIAlzY2Fu c3RhdGUtPnByZWZldGNoX3RhcmdldCA9IDA7CkBAIC04NDAsNyArODUxLDIyIEBAIHZvaWQK IEV4ZWNCaXRtYXBIZWFwRXN0aW1hdGUoQml0bWFwSGVhcFNjYW5TdGF0ZSAqbm9kZSwKIAkJ CQkJICAgUGFyYWxsZWxDb250ZXh0ICpwY3h0KQogewotCXNobV90b2NfZXN0aW1hdGVfY2h1 bmsoJnBjeHQtPmVzdGltYXRvciwgc2l6ZW9mKFBhcmFsbGVsQml0bWFwSGVhcFN0YXRlKSk7 CisJU2l6ZQkJc2l6ZTsKKworCS8qCisJICogV2Ugc3RvcmUgUGFyYWxsZWxCaXRtYXBIZWFw U3RhdGUgZm9sbG93ZWQgYnkKKwkgKiBTaGFyZWRCaXRtYXBIZWFwSW5zdHJ1bWVudGF0aW9u SW5mbyBpbiB0aGUgc2FtZSBzaG1lbSBjaHVuay4KKwkgKi8KKwlzaXplID0gTUFYQUxJR04o c2l6ZW9mKFBhcmFsbGVsQml0bWFwSGVhcFN0YXRlKSk7CisKKwkvKiBkb24ndCBuZWVkIHRo aXMgaWYgbm90IGluc3RydW1lbnRpbmcgb3Igbm8gd29ya2VycyAqLworCWlmIChub2RlLT5z cy5wcy5pbnN0cnVtZW50ICYmIHBjeHQtPm53b3JrZXJzID4gMCkKKwl7CisJCXNpemUgPSBh ZGRfc2l6ZShzaXplLCBvZmZzZXRvZihTaGFyZWRCaXRtYXBIZWFwSW5zdHJ1bWVudGF0aW9u LCBzaW5zdHJ1bWVudCkpOworCQlzaXplID0gYWRkX3NpemUoc2l6ZSwgbXVsX3NpemUocGN4 dC0+bndvcmtlcnMsIHNpemVvZihCaXRtYXBIZWFwU2Nhbkluc3RydW1lbnRhdGlvbikpKTsK Kwl9CisKKwlzaG1fdG9jX2VzdGltYXRlX2NodW5rKCZwY3h0LT5lc3RpbWF0b3IsIHNpemUp OwogCXNobV90b2NfZXN0aW1hdGVfa2V5cygmcGN4dC0+ZXN0aW1hdG9yLCAxKTsKIH0KIApA QCAtODU1LDEzICs4ODEsMjcgQEAgRXhlY0JpdG1hcEhlYXBJbml0aWFsaXplRFNNKEJpdG1h cEhlYXBTY2FuU3RhdGUgKm5vZGUsCiAJCQkJCQkJUGFyYWxsZWxDb250ZXh0ICpwY3h0KQog ewogCVBhcmFsbGVsQml0bWFwSGVhcFN0YXRlICpwc3RhdGU7CisJU2hhcmVkQml0bWFwSGVh cEluc3RydW1lbnRhdGlvbiAqc2luc3RydW1lbnQgPSBOVUxMOwogCWRzYV9hcmVhICAgKmRz YSA9IG5vZGUtPnNzLnBzLnN0YXRlLT5lc19xdWVyeV9kc2E7CisJY2hhcgkgICAqcHRyOwor CVNpemUJCXNpemU7CiAKIAkvKiBJZiB0aGVyZSdzIG5vIERTQSwgdGhlcmUgYXJlIG5vIHdv cmtlcnM7IGluaXRpYWxpemUgbm90aGluZy4gKi8KIAlpZiAoZHNhID09IE5VTEwpCiAJCXJl dHVybjsKIAotCXBzdGF0ZSA9IHNobV90b2NfYWxsb2NhdGUocGN4dC0+dG9jLCBzaXplb2Yo UGFyYWxsZWxCaXRtYXBIZWFwU3RhdGUpKTsKKwlzaXplID0gTUFYQUxJR04oc2l6ZW9mKFBh cmFsbGVsQml0bWFwSGVhcFN0YXRlKSk7CisJaWYgKG5vZGUtPnNzLnBzLmluc3RydW1lbnQg JiYgcGN4dC0+bndvcmtlcnMgPiAwKQorCXsKKwkJc2l6ZSA9IGFkZF9zaXplKHNpemUsIG9m ZnNldG9mKFNoYXJlZEJpdG1hcEhlYXBJbnN0cnVtZW50YXRpb24sIHNpbnN0cnVtZW50KSk7 CisJCXNpemUgPSBhZGRfc2l6ZShzaXplLCBtdWxfc2l6ZShwY3h0LT5ud29ya2Vycywgc2l6 ZW9mKEJpdG1hcEhlYXBTY2FuSW5zdHJ1bWVudGF0aW9uKSkpOworCX0KKworCXB0ciA9IHNo bV90b2NfYWxsb2NhdGUocGN4dC0+dG9jLCBzaXplKTsKKwlwc3RhdGUgPSAoUGFyYWxsZWxC aXRtYXBIZWFwU3RhdGUgKikgcHRyOworCXB0ciArPSBNQVhBTElHTihzaXplb2YoUGFyYWxs ZWxCaXRtYXBIZWFwU3RhdGUpKTsKKwlpZiAobm9kZS0+c3MucHMuaW5zdHJ1bWVudCAmJiBw Y3h0LT5ud29ya2VycyA+IDApCisJCXNpbnN0cnVtZW50ID0gKFNoYXJlZEJpdG1hcEhlYXBJ bnN0cnVtZW50YXRpb24gKikgcHRyOwogCiAJcHN0YXRlLT50Ym1pdGVyYXRvciA9IDA7CiAJ cHN0YXRlLT5wcmVmZXRjaF9pdGVyYXRvciA9IDA7CkBAIC04NzQsOCArOTE0LDE2IEBAIEV4 ZWNCaXRtYXBIZWFwSW5pdGlhbGl6ZURTTShCaXRtYXBIZWFwU2NhblN0YXRlICpub2RlLAog CiAJQ29uZGl0aW9uVmFyaWFibGVJbml0KCZwc3RhdGUtPmN2KTsKIAorCS8qIGVuc3VyZSBh bnkgdW5maWxsZWQgc2xvdHMgd2lsbCBjb250YWluIHplcm9lcyAqLworCWlmIChzaW5zdHJ1 bWVudCkKKwl7CisJCXNpbnN0cnVtZW50LT5udW1fd29ya2VycyA9IHBjeHQtPm53b3JrZXJz OworCQltZW1zZXQoc2luc3RydW1lbnQtPnNpbnN0cnVtZW50LCAwLCBwY3h0LT5ud29ya2Vy cyAqIHNpemVvZihCaXRtYXBIZWFwU2Nhbkluc3RydW1lbnRhdGlvbikpOworCX0KKwogCXNo bV90b2NfaW5zZXJ0KHBjeHQtPnRvYywgbm9kZS0+c3MucHMucGxhbi0+cGxhbl9ub2RlX2lk LCBwc3RhdGUpOwogCW5vZGUtPnBzdGF0ZSA9IHBzdGF0ZTsKKwlub2RlLT5zaW5zdHJ1bWVu dCA9IHNpbnN0cnVtZW50OwogfQogCiAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCkBAIC05MTcsMTAgKzk2NSwz NyBAQCB2b2lkCiBFeGVjQml0bWFwSGVhcEluaXRpYWxpemVXb3JrZXIoQml0bWFwSGVhcFNj YW5TdGF0ZSAqbm9kZSwKIAkJCQkJCQkgICBQYXJhbGxlbFdvcmtlckNvbnRleHQgKnB3Y3h0 KQogewotCVBhcmFsbGVsQml0bWFwSGVhcFN0YXRlICpwc3RhdGU7CisJY2hhcgkgICAqcHRy OwogCiAJQXNzZXJ0KG5vZGUtPnNzLnBzLnN0YXRlLT5lc19xdWVyeV9kc2EgIT0gTlVMTCk7 CiAKLQlwc3RhdGUgPSBzaG1fdG9jX2xvb2t1cChwd2N4dC0+dG9jLCBub2RlLT5zcy5wcy5w bGFuLT5wbGFuX25vZGVfaWQsIGZhbHNlKTsKLQlub2RlLT5wc3RhdGUgPSBwc3RhdGU7CisJ cHRyID0gc2htX3RvY19sb29rdXAocHdjeHQtPnRvYywgbm9kZS0+c3MucHMucGxhbi0+cGxh bl9ub2RlX2lkLCBmYWxzZSk7CisKKwlub2RlLT5wc3RhdGUgPSAoUGFyYWxsZWxCaXRtYXBI ZWFwU3RhdGUgKikgcHRyOworCXB0ciArPSBNQVhBTElHTihzaXplb2YoUGFyYWxsZWxCaXRt YXBIZWFwU3RhdGUpKTsKKworCWlmIChub2RlLT5zcy5wcy5pbnN0cnVtZW50KQorCQlub2Rl LT5zaW5zdHJ1bWVudCA9IChTaGFyZWRCaXRtYXBIZWFwSW5zdHJ1bWVudGF0aW9uICopIHB0 cjsKK30KKworLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICoJCUV4ZWNCaXRtYXBIZWFwUmV0cmlldmVJbnN0 cnVtZW50YXRpb24KKyAqCisgKgkJVHJhbnNmZXIgYml0bWFwIGhlYXAgc2NhbiBzdGF0aXN0 aWNzIGZyb20gRFNNIHRvIHByaXZhdGUgbWVtb3J5LgorICogLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICovCit2 b2lkCitFeGVjQml0bWFwSGVhcFJldHJpZXZlSW5zdHJ1bWVudGF0aW9uKEJpdG1hcEhlYXBT Y2FuU3RhdGUgKm5vZGUpCit7CisJU2hhcmVkQml0bWFwSGVhcEluc3RydW1lbnRhdGlvbiAq c2luc3RydW1lbnQgPSBub2RlLT5zaW5zdHJ1bWVudDsKKwlTaXplCQlzaXplOworCisJaWYg KHNpbnN0cnVtZW50ID09IE5VTEwpCisJCXJldHVybjsKKworCXNpemUgPSBvZmZzZXRvZihT aGFyZWRCaXRtYXBIZWFwSW5zdHJ1bWVudGF0aW9uLCBzaW5zdHJ1bWVudCkKKwkJKyBzaW5z dHJ1bWVudC0+bnVtX3dvcmtlcnMgKiBzaXplb2YoQml0bWFwSGVhcFNjYW5JbnN0cnVtZW50 YXRpb24pOworCisJbm9kZS0+c2luc3RydW1lbnQgPSBwYWxsb2Moc2l6ZSk7CisJbWVtY3B5 KG5vZGUtPnNpbnN0cnVtZW50LCBzaW5zdHJ1bWVudCwgc2l6ZSk7CiB9CmRpZmYgLS1naXQg YS9zcmMvaW5jbHVkZS9leGVjdXRvci9ub2RlQml0bWFwSGVhcHNjYW4uaCBiL3NyYy9pbmNs dWRlL2V4ZWN1dG9yL25vZGVCaXRtYXBIZWFwc2Nhbi5oCmluZGV4IGVhMDAzYTljYWFlLi40 NDZhNjY0NTkwYSAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvZXhlY3V0b3Ivbm9kZUJpdG1h cEhlYXBzY2FuLmgKKysrIGIvc3JjL2luY2x1ZGUvZXhlY3V0b3Ivbm9kZUJpdG1hcEhlYXBz Y2FuLmgKQEAgLTI4LDUgKzI4LDYgQEAgZXh0ZXJuIHZvaWQgRXhlY0JpdG1hcEhlYXBSZUlu aXRpYWxpemVEU00oQml0bWFwSGVhcFNjYW5TdGF0ZSAqbm9kZSwKIAkJCQkJCQkJCQkgIFBh cmFsbGVsQ29udGV4dCAqcGN4dCk7CiBleHRlcm4gdm9pZCBFeGVjQml0bWFwSGVhcEluaXRp YWxpemVXb3JrZXIoQml0bWFwSGVhcFNjYW5TdGF0ZSAqbm9kZSwKIAkJCQkJCQkJCQkgICBQ YXJhbGxlbFdvcmtlckNvbnRleHQgKnB3Y3h0KTsKK2V4dGVybiB2b2lkIEV4ZWNCaXRtYXBI ZWFwUmV0cmlldmVJbnN0cnVtZW50YXRpb24oQml0bWFwSGVhcFNjYW5TdGF0ZSAqbm9kZSk7 CiAKICNlbmRpZgkJCQkJCQkvKiBOT0RFQklUTUFQSEVBUFNDQU5fSCAqLwpkaWZmIC0tZ2l0 IGEvc3JjL2luY2x1ZGUvbm9kZXMvZXhlY25vZGVzLmggYi9zcmMvaW5jbHVkZS9ub2Rlcy9l eGVjbm9kZXMuaAppbmRleCAyNzYxNGFiNTBmYi4uMTEyNGE1MWNkMjEgMTAwNjQ0Ci0tLSBh L3NyYy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rlcy5oCisrKyBiL3NyYy9pbmNsdWRlL25vZGVz L2V4ZWNub2Rlcy5oCkBAIC0xNjU5LDYgKzE2NTksMTIgQEAgdHlwZWRlZiBzdHJ1Y3QgQml0 bWFwSW5kZXhTY2FuU3RhdGUKIAlzdHJ1Y3QgSW5kZXhTY2FuRGVzY0RhdGEgKmJpc3NfU2Nh bkRlc2M7CiB9IEJpdG1hcEluZGV4U2NhblN0YXRlOwogCit0eXBlZGVmIHN0cnVjdCBCaXRt YXBIZWFwU2Nhbkluc3RydW1lbnRhdGlvbgoreworCWxvbmcgbG9zc3lfcGFnZXM7CisJbG9u ZyBleGFjdF9wYWdlczsKK30gQml0bWFwSGVhcFNjYW5JbnN0cnVtZW50YXRpb247CisKIC8q IC0tLS0tLS0tLS0tLS0tLS0KICAqCSBTaGFyZWRCaXRtYXBTdGF0ZSBpbmZvcm1hdGlvbgog ICoKQEAgLTE3MDIsNiArMTcwOCwyMCBAQCB0eXBlZGVmIHN0cnVjdCBQYXJhbGxlbEJpdG1h cEhlYXBTdGF0ZQogCUNvbmRpdGlvblZhcmlhYmxlIGN2OwogfSBQYXJhbGxlbEJpdG1hcEhl YXBTdGF0ZTsKIAorLyogLS0tLS0tLS0tLS0tLS0tLQorICoJIEluc3RydW1lbnRhdGlvbiBk YXRhIGZvciBhIHBhcmFsbGVsIGJpdG1hcCBoZWFwIHNjYW4uCisgKgorICogRHVyaW5nIGEg cGFyYWxsZWwgYml0bWFwIGhlYXAgc2NhbiwgdGhpcyBsaXZlcyBpbiBzaGFyZWQgbWVtb3J5 LiAgQXQgdGhlCisgKiBlbmQsIGVhY2ggd29ya2VyIGNvcGllcyB0aGVpciBvd24gc3RhdHMg dG8gdGhlIHJpZ2h0IHNsb3QuICBGaW5hbGx5LCB0aGUKKyAqIGxlYWRlciBjb3BpZXMgdGhl IGRhdGEgdG8gaXRzIGxvY2FsIG1lbW9yeQorICAqIC0tLS0tLS0tLS0tLS0tLS0KKyAqLwor dHlwZWRlZiBzdHJ1Y3QgU2hhcmVkQml0bWFwSGVhcEluc3RydW1lbnRhdGlvbgoreworCWlu dAkJCW51bV93b3JrZXJzOworCUJpdG1hcEhlYXBTY2FuSW5zdHJ1bWVudGF0aW9uIHNpbnN0 cnVtZW50W0ZMRVhJQkxFX0FSUkFZX01FTUJFUl07Cit9IFNoYXJlZEJpdG1hcEhlYXBJbnN0 cnVtZW50YXRpb247CisKIC8qIC0tLS0tLS0tLS0tLS0tLS0KICAqCSBCaXRtYXBIZWFwU2Nh blN0YXRlIGluZm9ybWF0aW9uCiAgKgpAQCAtMTczNiw4ICsxNzU2LDYgQEAgdHlwZWRlZiBz dHJ1Y3QgQml0bWFwSGVhcFNjYW5TdGF0ZQogCWludAkJCXJldHVybl9lbXB0eV90dXBsZXM7 CiAJQnVmZmVyCQl2bWJ1ZmZlcjsKIAlCdWZmZXIJCXB2bWJ1ZmZlcjsKLQlsb25nCQlleGFj dF9wYWdlczsKLQlsb25nCQlsb3NzeV9wYWdlczsKIAlUQk1JdGVyYXRvciAqcHJlZmV0Y2hf aXRlcmF0b3I7CiAJaW50CQkJcHJlZmV0Y2hfcGFnZXM7CiAJaW50CQkJcHJlZmV0Y2hfdGFy Z2V0OwpAQCAtMTc0Niw2ICsxNzY0LDE3IEBAIHR5cGVkZWYgc3RydWN0IEJpdG1hcEhlYXBT Y2FuU3RhdGUKIAlUQk1TaGFyZWRJdGVyYXRvciAqc2hhcmVkX3RibWl0ZXJhdG9yOwogCVRC TVNoYXJlZEl0ZXJhdG9yICpzaGFyZWRfcHJlZmV0Y2hfaXRlcmF0b3I7CiAJUGFyYWxsZWxC aXRtYXBIZWFwU3RhdGUgKnBzdGF0ZTsKKworCS8qCisJICogSW4gYSBwYXJhbGxlbGl6ZWQg Yml0bWFwIGhlYXAgc2NhbiwgZWFjaCB3b3JrZXIgc2V0cyB0aGVpcgorCSAqIGluc3RydW1l bnRhdG9uIGRhdGEgaW4gcHN0YXRlLT5zaW5zdHJ1bWVudCBhdCB0aGUgZW5kLiAgVGhlIGxl YWRlcgorCSAqIGNvcGllcyB0aGUgc2hhcmVkLW1lbW9yeSBpbmZvIGJhY2sgdG8gbG9jYWwg c3RvcmFnZSBiZWZvcmUgRFNNCisJICogc2h1dGRvd24sIGFuZCBzdG9yZXMgaXQgaGVyZSBp biAnaW5zdHJ1bWVudCcuICBJdCByZW1haW5zIE5VTEwgaW4KKwkgKiB3b3JrZXJzIGFuZCBp biBub24tcGFyYWxsZWwgc2NhbnMuCisJICovCisJU2hhcmVkQml0bWFwSGVhcEluc3RydW1l bnRhdGlvbiAqc2luc3RydW1lbnQ7CisKKwlCaXRtYXBIZWFwU2Nhbkluc3RydW1lbnRhdGlv biBzdGF0czsKIH0gQml0bWFwSGVhcFNjYW5TdGF0ZTsKIAogLyogLS0tLS0tLS0tLS0tLS0t LQotLSAKMi4zOS4yCgo= --------------FT3HFu113HfSiGVwZLhSHeHk--