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 1wfKJp-005OZ5-0j for pgsql-hackers@arkaria.postgresql.org; Thu, 02 Jul 2026 16:31:17 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1wfKJn-002FkW-33 for pgsql-hackers@arkaria.postgresql.org; Thu, 02 Jul 2026 16:31:15 +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 1wfKJn-002FkN-1r for pgsql-hackers@lists.postgresql.org; Thu, 02 Jul 2026 16:31:15 +0000 Received: from mail-yx1-xb129.google.com ([2607:f8b0:4864:20::b129]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1wfKJk-00000001Nux-3aus for pgsql-hackers@lists.postgresql.org; Thu, 02 Jul 2026 16:31:14 +0000 Received: by mail-yx1-xb129.google.com with SMTP id 956f58d0204a3-664b05d408bso1916227d50.1 for ; Thu, 02 Jul 2026 09:31:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1783009871; x=1783614671; darn=lists.postgresql.org; h=cc:subject:to:from:content-language:user-agent:mime-version:date :message-id:from:to:cc:subject:date:message-id:reply-to; bh=YszhIRh6Ks2aZ94RRO9dcqD7GFdg8H2uF7d+V0vH9NU=; b=VNNcVMW4Nj88s4sBjrRcvAecHXpz2OF3rbVhBU7L08aJA0ntVSRxUmKAxzwJa0mTa1 ZnK3Fmjca5ikMvAfhaq/NSQaNr5b3RcMNrW9Q1MAfcUbqJqriBu9III93nml0MkcNmEd YdHGXBiLqnkNeeeSfo4Bx+LwWNZMS7krxLQndbDsseK8q7JyqubpQNHn2Ndi8qzgSvIi lU8cFRrnbUyGv278nwZGiFAyg0Ik0JEZII1LzW7DF6cfcnuC6rZZIBIEvP+oa6HrZ6ez Y+xhO7DwaCdSDd1XY/K0bEPGdvg78ccRSNVehHAytAh9ihVpkOhH2wXmRft0GYs9kONn 5gTg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1783009871; x=1783614671; h=cc:subject:to:from:content-language:user-agent:mime-version:date :message-id:x-gm-gg:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=YszhIRh6Ks2aZ94RRO9dcqD7GFdg8H2uF7d+V0vH9NU=; b=hCfsC6peVRHDMEbf4wQA/63JAudR2jJapJFbv12FKzsDJGWwsRaoDrx4XT724cJ7ir TL8LtSLXH72uBBDVDXB458m8Dx4oxZSXGdwDti61e/hGUUR/bNknyUi5RyeWm7m2gxO/ ufsPB06gCXvELlcnfUBy9DcUEwdd//S2pkA0pytIKrEBPK7l24t1XGm0xXdbx1ys2Rlk 1nH+Lu8JGhWU8PCiDYlkNoSjMxyj7U70jOzJ+ItMVoubzyGCqL8lrWj9fWAZTY+BUmd1 u34hdGXjkb8u/JI58y1c/yZgPh3TnGpEENeJ8zb7Q3iSi45a8xbK/BDvQisml9OVvJgO hO2g== X-Gm-Message-State: AOJu0Yxl+XF1XqKLwJJGStWEJVGvRN9Zu4Z2qvMbxcPVhPT1aKfR320m PzQpGP7Ktiwj3GYg217IwcOffO4qJMXLGrCy8zP3CB0Gq5HashQIztFJA2MfAODx X-Gm-Gg: AfdE7cmNrnpdEbe7j4xky8d/7XURkOm8crE5LV9TwFuBVUXk9Q/vAgMmMdYO4BplOgq KhkmmySkORxzHudqR/pr4uh4xDvy5HjObQZCCqBReORyHFsWY7toH0Yt/qUo0BtaLfWL24B1WEd dtS34TPJ3CaVab7JQrGCU6wX4+8z8I90hrZAwbY7gEEW4WNCAORY+uzcdrRb1/84lHS3ciNbyGM R0tRF0i0jnRKegYbDR/j0dlWy7g4H5sH/RsCal6oGXZHQcMjM00RrO37zo65i4p5jCK2vrPwuWQ TmYYi46Jl3uI7h6E1+Y/qC8W9DBCNgCxcuFFs8nPlPPvkE0UgyoLfLVk0P5HYzGNYy0CfAlMbwX rMXdKuUm+xMKRA/RK9GCy12KFRfyt0hf/Byx0HQQ6LhPD+3gJSmB5i8M7g7rRxXVrAbkAKOOFx/ QmUrb59PchT0aU71LckTzjEoQxmSfOt03WI6H4J6akMmtSIf8E7X7kqUVbXEwXM647VxjoiD/qc e7kp2gsaINqJToXdavwxlxDvA== X-Received: by 2002:a05:690e:190c:b0:664:ae6a:ee9 with SMTP id 956f58d0204a3-66596648abdmr6230157d50.71.1783009870404; Thu, 02 Jul 2026 09:31:10 -0700 (PDT) Received: from ?IPV6:2600:1700:8952:80:c066:d6c3:fa90:ffd1? ([2600:1700:8952:80:c066:d6c3:fa90:ffd1]) by smtp.gmail.com with ESMTPSA id 956f58d0204a3-6662411dfa8sm1294479d50.19.2026.07.02.09.31.08 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Thu, 02 Jul 2026 09:31:09 -0700 (PDT) Content-Type: multipart/mixed; boundary="------------yEwnwzcggiNX0fD93pGfk8bz" Message-ID: <8c712d76-ecf7-4749-a6d8-dddc01f298ec@gmail.com> Date: Thu, 2 Jul 2026 11:30:39 -0500 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Content-Language: en-US From: Bryan Green To: PostgreSQL Hackers Subject: pg_dump: use threads for parallel workers on all platforms Cc: Thomas Munro , Andrew Dunstan 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. --------------yEwnwzcggiNX0fD93pGfk8bz Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit pg_dump runs parallel workers in two completely different ways. On non-Windows platforms, they're forked processes communicating with the leader over pipes-- which is what pipes and processes are for. Windows has no fork(), so there the workers are threads. But instead of coordinating those threads as threads, the Windows port runs the same process-based protocol on top of them, unchanged. Each worker's channel to the leader is a loopback TCP socketpair on 127.0.0.1, opened when the worker starts. So to tell a worker "dump table 1234," the leader serializes the command to a string and writes it down that socket; the worker reads it back a byte at a time, and the leader watches the sockets with select() to see who's done. All of it to hand work to a thread a few megabytes away in the same address space. And because the leader waits on the workers with WaitForMultipleObjects, which takes at most 64 handles, you can't run more than 64 jobs on Windows. The parallelism limit there is a limit of the wait call. (The non-Windows side doesn't have this limit-- it reaps workers with wait() rather than WaitForMultipleObjects, so PG_MAX_JOBS is INT_MAX.) None of this is broken; it works. It's threads pretending to be processes because the code was written for processes, and the port kept the protocol rather than rethinking it. I'd like to stop. One model everywhere should be threads on all platforms, coordinated by an in-process work queue-- a mutex and a couple of condition variables-- instead of two worker models bridged by an inter-process protocol. To be clear, the unification is on the queue, not on what Windows does today. Teaching the non-Windows side to talk to its own threads over a socket, a byte at a time, would just be the same trick on more platforms-- that's the part worth deleting, not copying. I've done the Windows half, both to prove it out and because it's the coordination layer the non-Windows side would adopt. The socket protocol is gone; the leader hands work to a worker in memory instead of down a loopback connection. The 64-job cap is gone. The unchecked _beginthreadex return-- which on failure recorded a thread that didn't exist as an idle worker-- is fixed. Dump and restore are byte-for-byte identical to stock from -j2 through -j250. The non-Windows port to threads isn't written yet, and I won't start it until the direction is settled. One piece I deliberately left for the unified version: the queue still passes the command as a string-- "DUMP 1234"-- and the worker parses it back and looks the ID up to recover the TocEntry it already came from. In one address space that's ceremony; the queue could carry a { T_Action, TocEntry * } and drop the serialize/parse/lookup entirely. I didn't do it on Windows because the non-Windows side still forks, and a pointer is meaningless across a process boundary. There, the string is the serializer that path needs, so converting it to Windows-only would add a second message format instead of removing one. With threading in place across Windows and non-Windows, we can pass the work item directly and delete buildWorkerCommand/parseWorkerCommand and the matching response pair, plus the dumpId lookup, on every platform at once. The cost is crash isolation. fork() gives each non-Windows worker its own address space, so one that segfaults can't corrupt the leader or its siblings; threads give that up. What it actually buys today is narrow. The moment any worker dies, the leader pg_fatal()s and the whole dump comes down, so processes don't give you recovery-- only the guarantee that a corrupt worker can't scribble on a sibling's output before everyone exits. Windows has run without even that for years. It's an acceptable trade for a single implementation, but it's the real cost. I'll say plainly that this fixes no user-visible bug, and nothing is broken today. It's consolidation. There are two implementations of parallel dump right now, and they drift: the Windows one grew the socket emulation and the 64-job cap out of running a process protocol on threads, and it carried bugs the non-Windows side never had, like the _beginthreadex one above. One model means a fix or a feature lands once, on a path exercised on every platform, instead of twice, with a seam down the middle. Windows already shows the threaded model works here, and threads are the half both sides can share, since Windows can't fork. The Windows port originally kept the process shape to stay consistent with the other platforms; this keeps that same goal, on the model that actually ports. The strongest evidence of the thread-safety of the worker-reachable code-- Windows has run that path with threads for years. With the thread rework, fmtId's static return value, is now _Thread_local. The global state a worker reads is built during the single-threaded catalog phase, before any worker exists. Patches are attached-- 0001 and 0002 are independent and can be committed separately; 0004 depends on 0003. -- Bryan Green EDB: https://www.enterprisedb.com --------------yEwnwzcggiNX0fD93pGfk8bz Content-Type: text/plain; charset=UTF-8; name="v1-0001-pg_dump-check-for-_beginthreadex-failure-in-paral.patch" Content-Disposition: attachment; filename*0="v1-0001-pg_dump-check-for-_beginthreadex-failure-in-paral.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSA5YjQ2OTZiYjdmMjRiMmVmMjJlMjA0YWEzNjE3YzlhZDgxMTM3NDc2IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBCcnlhbiBHcmVlbiA8ZGJyeWFuLmdyZWVuQGdtYWls LmNvbT4KRGF0ZTogU3VuLCAyOCBKdW4gMjAyNiAxMDo1NDo1NCAtMDUwMApTdWJqZWN0OiBb UEFUQ0ggdjEgMS80XSBwZ19kdW1wOiBjaGVjayBmb3IgX2JlZ2ludGhyZWFkZXgoKSBmYWls dXJlIGluCiBwYXJhbGxlbCBkdW1wCgpQYXJhbGxlbEJhY2t1cFN0YXJ0KCkgc3RvcmVkIF9i ZWdpbnRocmVhZGV4KCkncyByZXR1cm4gdmFsdWUgYXMgdGhlCndvcmtlcidzIHRocmVhZCBo YW5kbGUgd2l0aG91dCBjaGVja2luZyBpdC4gIE9uIGZhaWx1cmUgdGhhdCB2YWx1ZSBpcyAw LAp3aGljaCB3b3VsZCBsYXRlciByZWFjaCBXYWl0Rm9yTXVsdGlwbGVPYmplY3RzKCkgYXMg YSBudWxsIGhhbmRsZSwgY2F1Z2h0Cm9ubHkgYnkgYW4gQXNzZXJ0LiAgVGhlIGZvcmsoKSBw YXRoIGFscmVhZHkgY2FsbHMgcGdfZmF0YWwoKSB3aGVuIGl0CmZhaWxzOyBkbyB0aGUgc2Ft ZSBmb3IgX2JlZ2ludGhyZWFkZXgoKSwgYXMgcGdiZW5jaCBkb2VzLgotLS0KIHNyYy9iaW4v cGdfZHVtcC9wYXJhbGxlbC5jIHwgMiArKwogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9u cygrKQoKZGlmZiAtLWdpdCBhL3NyYy9iaW4vcGdfZHVtcC9wYXJhbGxlbC5jIGIvc3JjL2Jp bi9wZ19kdW1wL3BhcmFsbGVsLmMKaW5kZXggM2U4NGI4ODFjYS4uYjc3ZDI2NTBkZiAxMDA2 NDQKLS0tIGEvc3JjL2Jpbi9wZ19kdW1wL3BhcmFsbGVsLmMKKysrIGIvc3JjL2Jpbi9wZ19k dW1wL3BhcmFsbGVsLmMKQEAgLTk3Niw2ICs5NzYsOCBAQCBQYXJhbGxlbEJhY2t1cFN0YXJ0 KEFyY2hpdmVIYW5kbGUgKkFIKQogCiAJCWhhbmRsZSA9IF9iZWdpbnRocmVhZGV4KE5VTEws IDAsICh2b2lkICopICZpbml0X3NwYXduZWRfd29ya2VyX3dpbjMyLAogCQkJCQkJCQl3aSwg MCwgJihzbG90LT50aHJlYWRJZCkpOworCQlpZiAoaGFuZGxlID09IDApCisJCQlwZ19mYXRh bCgiY291bGQgbm90IGNyZWF0ZSB3b3JrZXIgdGhyZWFkOiAlbSIpOwogCQlzbG90LT5oVGhy ZWFkID0gaGFuZGxlOwogCQlzbG90LT53b3JrZXJTdGF0dXMgPSBXUktSX0lETEU7CiAjZWxz ZQkJCQkJCQkvKiAhV0lOMzIgKi8KLS0gCjIuNTQuMC53aW5kb3dzLjEKCg== --------------yEwnwzcggiNX0fD93pGfk8bz Content-Type: text/plain; charset=UTF-8; name="v1-0002-Give-fmtId-s-temporary-buffer-thread-local-storag.patch" Content-Disposition: attachment; filename*0="v1-0002-Give-fmtId-s-temporary-buffer-thread-local-storag.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSAzYzFiODUxMGE1NDZhNTA0ZGQ1ODNjN2YwOTc5ZjY0NWMzMGI4YWM2IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBCcnlhbiBHcmVlbiA8ZGJyeWFuLmdyZWVuQGdtYWls LmNvbT4KRGF0ZTogU3VuLCAyOCBKdW4gMjAyNiAxMTo0MDo1OCAtMDUwMApTdWJqZWN0OiBb UEFUQ0ggdjEgMi80XSBHaXZlIGZtdElkKCkncyB0ZW1wb3JhcnkgYnVmZmVyIHRocmVhZC1s b2NhbCBzdG9yYWdlCgpnZXRMb2NhbFBRRXhwQnVmZmVyKCkgcmV0dXJucyBhIGZ1bmN0aW9u LXNjb3BlIHN0YXRpYyBidWZmZXIsIHVuc2FmZSB3aGVuCmZtdElkKCkgYW5kIGZtdFF1YWxp ZmllZElkKCkgcnVuIGluIG11bHRpcGxlIHRocmVhZHMuICBPbiBXaW5kb3dzLCB3aGVyZQpw Z19kdW1wJ3MgcGFyYWxsZWwgd29ya2VycyBhcmUgdGhyZWFkcywgdGhpcyB3YXMgcGF0Y2hl ZCBvdmVyIGF0IHJ1bnRpbWUKYnkgc3dhcHBpbmcgaW4gYSBUTFMtYmFzZWQgYnVmZmVyIGZy b20gUGFyYWxsZWxCYWNrdXBTdGFydCgpLgoKTWFyayB0aGUgZGVmYXVsdCBidWZmZXIgQzEx IF9UaHJlYWRfbG9jYWwgaW5zdGVhZC4gIEVhY2ggdGhyZWFkIGdldHMgaXRzCm93biwgc28g dGhlIFdpbmRvd3MgVGxzQWxsb2MvVGxzR2V0VmFsdWUgd29ya2Fyb3VuZCBhbmQgdGhlCmdl dExvY2FsUFFFeHBCdWZmZXIgZnVuY3Rpb24tcG9pbnRlciBzd2FwIGNhbiBnby4KLS0tCiBz cmMvYmluL3BnX2R1bXAvcGFyYWxsZWwuYyAgfCA1MiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCiBzcmMvZmVfdXRpbHMvc3RyaW5nX3V0aWxzLmMgfCAgNyArKy0t LQogMiBmaWxlcyBjaGFuZ2VkLCA0IGluc2VydGlvbnMoKyksIDU1IGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL3NyYy9iaW4vcGdfZHVtcC9wYXJhbGxlbC5jIGIvc3JjL2Jpbi9wZ19k dW1wL3BhcmFsbGVsLmMKaW5kZXggYjc3ZDI2NTBkZi4uMTJiNDYyMzc1ZCAxMDA2NDQKLS0t IGEvc3JjL2Jpbi9wZ19kdW1wL3BhcmFsbGVsLmMKKysrIGIvc3JjL2Jpbi9wZ19kdW1wL3Bh cmFsbGVsLmMKQEAgLTE5Myw5ICsxOTMsNiBAQCBzdGF0aWMgQ1JJVElDQUxfU0VDVElPTiBz aWduYWxfaW5mb19sb2NrOwogCiAKICNpZmRlZiBXSU4zMgotLyogZmlsZS1zY29wZSB2YXJp YWJsZXMgKi8KLXN0YXRpYyBEV09SRCB0bHNfaW5kZXg7Ci0KIC8qIGdsb2JhbGx5IHZpc2li bGUgdmFyaWFibGVzIChuZWVkZWQgYnkgZXhpdF9uaWNlbHkpICovCiBib29sCQlwYXJhbGxl bF9pbml0X2RvbmUgPSBmYWxzZTsKIERXT1JECQltYWluVGhyZWFkSWQ7CkBAIC0yNDMsOCAr MjQwLDYgQEAgaW5pdF9wYXJhbGxlbF9kdW1wX3V0aWxzKHZvaWQpCiAJCVdTQURBVEEJCXdz YURhdGE7CiAJCWludAkJCWVycjsKIAotCQkvKiBQcmVwYXJlIGZvciB0aHJlYWRlZCBvcGVy YXRpb24gKi8KLQkJdGxzX2luZGV4ID0gVGxzQWxsb2MoKTsKIAkJbWFpblRocmVhZElkID0g R2V0Q3VycmVudFRocmVhZElkKCk7CiAKIAkJLyogSW5pdGlhbGl6ZSBzb2NrZXQgYWNjZXNz ICovCkBAIC0yODAsNDggKzI3NSw2IEBAIEdldE15UFNsb3QoUGFyYWxsZWxTdGF0ZSAqcHN0 YXRlKQogCXJldHVybiBOVUxMOwogfQogCi0vKgotICogQSB0aHJlYWQtbG9jYWwgdmVyc2lv biBvZiBnZXRMb2NhbFBRRXhwQnVmZmVyKCkuCi0gKgotICogTm9uLXJlZW50cmFudCBidXQg cmVkdWNlcyBtZW1vcnkgbGVha2FnZTogd2UnbGwgY29uc3VtZSBvbmUgYnVmZmVyIHBlcgot ICogdGhyZWFkLCB3aGljaCBpcyBtdWNoIGJldHRlciB0aGFuIG9uZSBwZXIgZm10SWQvZm10 UXVhbGlmaWVkSWQgY2FsbC4KLSAqLwotI2lmZGVmIFdJTjMyCi1zdGF0aWMgUFFFeHBCdWZm ZXIKLWdldFRocmVhZExvY2FsUFFFeHBCdWZmZXIodm9pZCkKLXsKLQkvKgotCSAqIFRoZSBU bHMgY29kZSBnb2VzIGF3cnkgaWYgd2UgdXNlIGEgc3RhdGljIHZhciwgc28gd2UgcHJvdmlk ZSBmb3IgYm90aAotCSAqIHN0YXRpYyBhbmQgYXV0bywgYW5kIG9taXQgYW55IHVzZSBvZiB0 aGUgc3RhdGljIHZhciB3aGVuIHVzaW5nIFRscy4gV2UKLQkgKiByZWx5IG9uIFRsc0dldFZh bHVlKCkgdG8gcmV0dXJuIDAgaWYgdGhlIHZhbHVlIGlzIG5vdCB5ZXQgc2V0LgotCSAqLwot CXN0YXRpYyBQUUV4cEJ1ZmZlciBzX2lkX3JldHVybiA9IE5VTEw7Ci0JUFFFeHBCdWZmZXIg aWRfcmV0dXJuOwotCi0JaWYgKHBhcmFsbGVsX2luaXRfZG9uZSkKLQkJaWRfcmV0dXJuID0g KFBRRXhwQnVmZmVyKSBUbHNHZXRWYWx1ZSh0bHNfaW5kZXgpOwotCWVsc2UKLQkJaWRfcmV0 dXJuID0gc19pZF9yZXR1cm47Ci0KLQlpZiAoaWRfcmV0dXJuKQkJCQkvKiBmaXJzdCB0aW1l IHRocm91Z2g/ICovCi0JewotCQkvKiBzYW1lIGJ1ZmZlciwganVzdCB3aXBlIGNvbnRlbnRz ICovCi0JCXJlc2V0UFFFeHBCdWZmZXIoaWRfcmV0dXJuKTsKLQl9Ci0JZWxzZQotCXsKLQkJ LyogbmV3IGJ1ZmZlciAqLwotCQlpZF9yZXR1cm4gPSBjcmVhdGVQUUV4cEJ1ZmZlcigpOwot CQlpZiAocGFyYWxsZWxfaW5pdF9kb25lKQotCQkJVGxzU2V0VmFsdWUodGxzX2luZGV4LCBp ZF9yZXR1cm4pOwotCQllbHNlCi0JCQlzX2lkX3JldHVybiA9IGlkX3JldHVybjsKLQl9Ci0K LQlyZXR1cm4gaWRfcmV0dXJuOwotfQotI2VuZGlmCQkJCQkJCS8qIFdJTjMyICovCi0KIC8q CiAgKiBwZ19kdW1wIGFuZCBwZ19yZXN0b3JlIGNhbGwgdGhpcyB0byByZWdpc3RlciB0aGUg Y2xlYW51cCBoYW5kbGVyCiAgKiBhcyBzb29uIGFzIHRoZXkndmUgY3JlYXRlZCB0aGUgQXJj aGl2ZUhhbmRsZS4KQEAgLTkxOCwxMSArODcxLDYgQEAgUGFyYWxsZWxCYWNrdXBTdGFydChB cmNoaXZlSGFuZGxlICpBSCkKIAlwc3RhdGUtPnBhcmFsbGVsU2xvdCA9CiAJCXBnX21hbGxv YzBfYXJyYXkoUGFyYWxsZWxTbG90LCBwc3RhdGUtPm51bVdvcmtlcnMpOwogCi0jaWZkZWYg V0lOMzIKLQkvKiBNYWtlIGZtdElkKCkgYW5kIGZtdFF1YWxpZmllZElkKCkgdXNlIHRocmVh ZC1sb2NhbCBzdG9yYWdlICovCi0JZ2V0TG9jYWxQUUV4cEJ1ZmZlciA9IGdldFRocmVhZExv Y2FsUFFFeHBCdWZmZXI7Ci0jZW5kaWYKLQogCS8qCiAJICogU2V0IHRoZSBwc3RhdGUgaW4g c2h1dGRvd25faW5mbywgdG8gdGVsbCB0aGUgZXhpdCBoYW5kbGVyIHRoYXQgaXQgbXVzdAog CSAqIGNsZWFuIHVwIHdvcmtlcnMgYXMgd2VsbCBhcyB0aGUgbWFpbiBkYXRhYmFzZSBjb25u ZWN0aW9uLiAgQnV0IHdlIGRvbid0CmRpZmYgLS1naXQgYS9zcmMvZmVfdXRpbHMvc3RyaW5n X3V0aWxzLmMgYi9zcmMvZmVfdXRpbHMvc3RyaW5nX3V0aWxzLmMKaW5kZXggN2E3NjIyNTFm My4uYjM3MzhjMjVkYiAxMDA2NDQKLS0tIGEvc3JjL2ZlX3V0aWxzL3N0cmluZ191dGlscy5j CisrKyBiL3NyYy9mZV91dGlscy9zdHJpbmdfdXRpbHMuYwpAQCAtMzQsMTQgKzM0LDE1IEBA IHN0YXRpYyBpbnQJZm10SWRFbmNvZGluZyA9IC0xOwogICogUmV0dXJucyBhIHRlbXBvcmFy eSBQUUV4cEJ1ZmZlciwgdmFsaWQgdW50aWwgdGhlIG5leHQgY2FsbCB0byB0aGUgZnVuY3Rp b24uCiAgKiBUaGlzIGlzIHVzZWQgYnkgZm10SWQgYW5kIGZtdFF1YWxpZmllZElkLgogICoK LSAqIE5vbi1yZWVudHJhbnQgYW5kIG5vbi10aHJlYWQtc2FmZSBidXQgcmVkdWNlcyBtZW1v cnkgbGVha2FnZS4gWW91IGNhbgotICogcmVwbGFjZSB0aGlzIHdpdGggYSBjdXN0b20gdmVy c2lvbiBieSBzZXR0aW5nIHRoZSBnZXRMb2NhbFBRRXhwQnVmZmVyCisgKiBUaGUgYnVmZmVy IGlzIHRocmVhZC1sb2NhbCwgc28gdGhpcyBpcyBzYWZlIHRvIGNhbGwgZnJvbSBtdWx0aXBs ZSB0aHJlYWRzCisgKiBhdCBvbmNlOyBlYWNoIHRocmVhZCBnZXRzIGl0cyBvd24uIE5vdCBy ZWVudHJhbnQgd2l0aGluIGEgdGhyZWFkLCBidXQgaXQKKyAqIHJlZHVjZXMgbWVtb3J5IGxl YWthZ2UuIFJlcGxhY2UgaXQgYnkgc2V0dGluZyB0aGUgZ2V0TG9jYWxQUUV4cEJ1ZmZlcgog ICogZnVuY3Rpb24gcG9pbnRlci4KICAqLwogc3RhdGljIFBRRXhwQnVmZmVyCiBkZWZhdWx0 R2V0TG9jYWxQUUV4cEJ1ZmZlcih2b2lkKQogewotCXN0YXRpYyBQUUV4cEJ1ZmZlciBpZF9y ZXR1cm4gPSBOVUxMOworCXN0YXRpYyBfVGhyZWFkX2xvY2FsIFBRRXhwQnVmZmVyIGlkX3Jl dHVybiA9IE5VTEw7CiAKIAlpZiAoaWRfcmV0dXJuKQkJCQkvKiBmaXJzdCB0aW1lIHRocm91 Z2g/ICovCiAJewotLSAKMi41NC4wLndpbmRvd3MuMQoK --------------yEwnwzcggiNX0fD93pGfk8bz Content-Type: text/plain; charset=UTF-8; name="v1-0003-pg_dump-dispatch-parallel-workers-in-process-on-W.patch" Content-Disposition: attachment; filename*0="v1-0003-pg_dump-dispatch-parallel-workers-in-process-on-W.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSA0MDUxZGZkNTZmYTY4OTQ4YzM4NjQ2MzRmOGUyMGZhNGQzODZlOTRlIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBCcnlhbiBHcmVlbiA8ZGJyeWFuLmdyZWVuQGdtYWls LmNvbT4KRGF0ZTogU3VuLCAyOCBKdW4gMjAyNiAxMjowNToxMCAtMDUwMApTdWJqZWN0OiBb UEFUQ0ggdjEgMy80XSBwZ19kdW1wOiBkaXNwYXRjaCBwYXJhbGxlbCB3b3JrZXJzIGluLXBy b2Nlc3Mgb24KIFdpbmRvd3MKCk9uIFdpbmRvd3MgdGhlIHBhcmFsbGVsIHdvcmtlcnMgYXJl IHRocmVhZHMgaW4gdGhlIGxlYWRlcidzIHByb2Nlc3MsIGJ1dAp0aGV5IHJlYWNoZWQgdGhl IGxlYWRlciB0aHJvdWdoIHRoZSBzYW1lIHRyYW5zcG9ydCBhcyBVbml4IHdvcmtlcgpwcm9j ZXNzZXM6IHBncGlwZSgpIChhIGxvb3BiYWNrIFRDUCBzb2NrZXQgcGFpciksIHNlbGVjdCgp LCBhbmQgYQpieXRlLWF0LWEtdGltZSBzdHJpbmcgcHJvdG9jb2wuICBUaGF0IGlzIHBvaW50 bGVzcyB3aGVuIHRoZSB3b3JrZXJzIHNoYXJlCnRoZSBsZWFkZXIncyBhZGRyZXNzIHNwYWNl LgoKR2l2ZSBlYWNoIFBhcmFsbGVsU2xvdCBhbiBpbi1wcm9jZXNzIGNoYW5uZWwgaW5zdGVh ZCAtLSBhIGNvbW1hbmQgc2xvdAphbmQgYSByZXNwb25zZSBzbG90IHVuZGVyIGEgY3JpdGlj YWwgc2VjdGlvbiwgd2l0aCBvbmUgY29uZGl0aW9uIHZhcmlhYmxlCnRvIHdha2UgdGhlIHdv cmtlciBhbmQgb25lIHRvIHdha2UgdGhlIGxlYWRlci4gIE1lc3NhZ2VzIHBhc3MgYXMgbWFs bG9jJ2QKc3RyaW5nczsgZGlzcGF0Y2ggd3JpdGVzIHRvIG1lbW9yeSByYXRoZXIgdGhhbiBh IHNvY2tldC4KClRoZSBwaXBlIGFsc28gc2lnbmFsbGVkIHdvcmtlciBkZWF0aCB0aHJvdWdo IEVPRi4gIFRoZSBjaGFubmVsIGhhcyBub25lLAphbmQgZXhpdF9uaWNlbHkoKSBlbmRzIG9u bHkgdGhlIHdvcmtlciB0aHJlYWQsIHNvIGEgZmFpbGVkIHdvcmtlciAtLSBmb3IKaW5zdGFu Y2UgYSBjb25uZWN0aW9uIHRoYXQgZmFpbHMgd2hlbiAtaiBleGNlZWRzIG1heF9jb25uZWN0 aW9ucyAtLSB3b3VsZApoYW5nIHRoZSBsZWFkZXIgZm9yZXZlci4gIEEgZHlpbmcgd29ya2Vy IG5vdyBzZXRzIHNsb3QtPndvcmtlckRpZWQgYW5kCndha2VzIHRoZSBsZWFkZXIsIGFuZCBn ZXRNZXNzYWdlRnJvbVdvcmtlcigpIHJldHVybnMgTlVMTCBqdXN0IGFzIHRoZQpVbml4IHBh dGggZG9lcyBvbiBFT0YuICBGb3IgdGhlIGxlYWRlciB0byBuYW1lIHRoZSBkZWFkIHdvcmtl ciwgZWFjaAp3b3JrZXIgcmVjb3JkcyBpdHMgb3duIHRocmVhZCBpZCBvbiBlbnRyeSByYXRo ZXIgdGhhbiB0cnVzdGluZwpfYmVnaW50aHJlYWRleCgpJ3Mgb3V0cHV0IGFyZ3VtZW50LCB3 aGljaCBjYW4gbGFnIHRoZSB0aHJlYWQncyBzdGFydC4KClRoZSBVbml4IHBhdGggaXMgdW50 b3VjaGVkOyB0aGUgbm93LXVudXNlZCBwZ3BpcGUoKSwgc2VsZWN0X2xvb3AoKSwgYW5kCnJl YWRNZXNzYWdlRnJvbVBpcGUoKSBzdGF5IHVudGlsIHRoZSB3b3JrZXIgbW9kZWwgaXMgdW5p ZmllZCBvbiB0aHJlYWRzLgotLS0KIHNyYy9iaW4vcGdfZHVtcC9wYXJhbGxlbC5jIHwgMTk3 ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0KIDEgZmlsZSBjaGFuZ2Vk LCAxNjcgaW5zZXJ0aW9ucygrKSwgMzAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3Jj L2Jpbi9wZ19kdW1wL3BhcmFsbGVsLmMgYi9zcmMvYmluL3BnX2R1bXAvcGFyYWxsZWwuYwpp bmRleCAxMmI0NjIzNzVkLi41NTJhOGMxNDllIDEwMDY0NAotLS0gYS9zcmMvYmluL3BnX2R1 bXAvcGFyYWxsZWwuYworKysgYi9zcmMvYmluL3BnX2R1bXAvcGFyYWxsZWwuYwpAQCAtMTA3 LDYgKzEwNywxOSBAQCBzdHJ1Y3QgUGFyYWxsZWxTbG90CiAJaW50CQkJcGlwZVJldlJlYWQ7 CS8qIGNoaWxkJ3MgZW5kIG9mIHRoZSBwaXBlcyAqLwogCWludAkJCXBpcGVSZXZXcml0ZTsK IAorI2lmZGVmIFdJTjMyCisKKwkvKgorCSAqIEluLXByb2Nlc3MgY2hhbm5lbCB1c2VkIGlu c3RlYWQgb2YgdGhlIHBpcGVzIHdoZW4gd29ya2VycyBhcmUgdGhyZWFkcy4KKwkgKiBBIG1l c3NhZ2UgaXMgYSBtYWxsb2MnZCBzdHJpbmc7IG93bmVyc2hpcCBwYXNzZXMgdG8gdGhlIHJl Y2VpdmVyLgorCSAqIFByb3RlY3RlZCBieSBtc2dfbG9jay4KKwkgKi8KKwljaGFyCSAgICpj bWRNc2c7CQkJLyogY29tbWFuZCBwZW5kaW5nIGZvciB0aGUgd29ya2VyLCBvciBOVUxMICov CisJY2hhcgkgICAqcmVzcE1zZzsJCS8qIHJlc3BvbnNlIHBlbmRpbmcgZm9yIHRoZSBsZWFk ZXIsIG9yIE5VTEwgKi8KKwlib29sCQljaGFuQ2xvc2VkOwkJLyogbGVhZGVyIGNsb3NlZCB0 aGUgY29tbWFuZCBjaGFubmVsIChFT0YpICovCisJYm9vbAkJd29ya2VyRGllZDsJCS8qIHdv cmtlciBleGl0ZWQgd2l0aG91dCBzZW5kaW5nIGEgcmVzcG9uc2UgKi8KKyNlbmRpZgorCiAJ LyogQ2hpbGQgcHJvY2Vzcy90aHJlYWQgaWRlbnRpdHkgaW5mbzogKi8KICNpZmRlZiBXSU4z MgogCXVpbnRwdHJfdAloVGhyZWFkOwpAQCAtMTc2LDYgKzE4OSwxNSBAQCBzdGF0aWMgdm9s YXRpbGUgRHVtcFNpZ25hbEluZm9ybWF0aW9uIHNpZ25hbF9pbmZvOwogCiAjaWZkZWYgV0lO MzIKIHN0YXRpYyBDUklUSUNBTF9TRUNUSU9OIHNpZ25hbF9pbmZvX2xvY2s7CisKKy8qCisg KiBTeW5jaHJvbml6YXRpb24gZm9yIHRoZSBpbi1wcm9jZXNzIGNoYW5uZWxzIChzZWUgc3Ry dWN0IFBhcmFsbGVsU2xvdCkuCisgKiBtc2dfbG9jayBwcm90ZWN0cyB0aGUgcGVyLXNsb3Qg Y21kTXNnL3Jlc3BNc2cvY2hhbkNsb3NlZC93b3JrZXJEaWVkIGZpZWxkczsKKyAqIHdvcmtl cl9jdiB3YWtlcyBhIHdvcmtlciwgbGVhZGVyX2N2IHdha2VzIHRoZSBsZWFkZXIuCisgKi8K K3N0YXRpYyBDUklUSUNBTF9TRUNUSU9OIG1zZ19sb2NrOworc3RhdGljIENPTkRJVElPTl9W QVJJQUJMRSB3b3JrZXJfY3Y7CitzdGF0aWMgQ09ORElUSU9OX1ZBUklBQkxFIGxlYWRlcl9j djsKICNlbmRpZgogCiAvKgpAQCAtMjEwLDExICsyMzIsMTEgQEAgc3RhdGljIHZvaWQgUnVu V29ya2VyKEFyY2hpdmVIYW5kbGUgKkFILCBQYXJhbGxlbFNsb3QgKnNsb3QpOwogc3RhdGlj IGludAlHZXRJZGxlV29ya2VyKFBhcmFsbGVsU3RhdGUgKnBzdGF0ZSk7CiBzdGF0aWMgYm9v bCBIYXNFdmVyeVdvcmtlclRlcm1pbmF0ZWQoUGFyYWxsZWxTdGF0ZSAqcHN0YXRlKTsKIHN0 YXRpYyB2b2lkIGxvY2tUYWJsZUZvcldvcmtlcihBcmNoaXZlSGFuZGxlICpBSCwgVG9jRW50 cnkgKnRlKTsKLXN0YXRpYyB2b2lkIFdhaXRGb3JDb21tYW5kcyhBcmNoaXZlSGFuZGxlICpB SCwgaW50IHBpcGVmZFsyXSk7CitzdGF0aWMgdm9pZCBXYWl0Rm9yQ29tbWFuZHMoQXJjaGl2 ZUhhbmRsZSAqQUgsIFBhcmFsbGVsU2xvdCAqc2xvdCk7CiBzdGF0aWMgYm9vbCBMaXN0ZW5U b1dvcmtlcnMoQXJjaGl2ZUhhbmRsZSAqQUgsIFBhcmFsbGVsU3RhdGUgKnBzdGF0ZSwKIAkJ CQkJCQlib29sIGRvX3dhaXQpOwotc3RhdGljIGNoYXIgKmdldE1lc3NhZ2VGcm9tTGVhZGVy KGludCBwaXBlZmRbMl0pOwotc3RhdGljIHZvaWQgc2VuZE1lc3NhZ2VUb0xlYWRlcihpbnQg cGlwZWZkWzJdLCBjb25zdCBjaGFyICpzdHIpOworc3RhdGljIGNoYXIgKmdldE1lc3NhZ2VG cm9tTGVhZGVyKFBhcmFsbGVsU2xvdCAqc2xvdCk7CitzdGF0aWMgdm9pZCBzZW5kTWVzc2Fn ZVRvTGVhZGVyKFBhcmFsbGVsU2xvdCAqc2xvdCwgY29uc3QgY2hhciAqc3RyKTsKIHN0YXRp YyBpbnQJc2VsZWN0X2xvb3AoaW50IG1heEZkLCBmZF9zZXQgKndvcmtlcnNldCk7CiBzdGF0 aWMgY2hhciAqZ2V0TWVzc2FnZUZyb21Xb3JrZXIoUGFyYWxsZWxTdGF0ZSAqcHN0YXRlLAog CQkJCQkJCQkgIGJvb2wgZG9fd2FpdCwgaW50ICp3b3JrZXIpOwpAQCAtMjQyLDYgKzI2NCwx MSBAQCBpbml0X3BhcmFsbGVsX2R1bXBfdXRpbHModm9pZCkKIAogCQltYWluVGhyZWFkSWQg PSBHZXRDdXJyZW50VGhyZWFkSWQoKTsKIAorCQkvKiBJbml0aWFsaXplIHRoZSBpbi1wcm9j ZXNzIG1lc3NhZ2UtY2hhbm5lbCBzeW5jaHJvbml6YXRpb24gKi8KKwkJSW5pdGlhbGl6ZUNy aXRpY2FsU2VjdGlvbigmbXNnX2xvY2spOworCQlJbml0aWFsaXplQ29uZGl0aW9uVmFyaWFi bGUoJndvcmtlcl9jdik7CisJCUluaXRpYWxpemVDb25kaXRpb25WYXJpYWJsZSgmbGVhZGVy X2N2KTsKKwogCQkvKiBJbml0aWFsaXplIHNvY2tldCBhY2Nlc3MgKi8KIAkJZXJyID0gV1NB U3RhcnR1cChNQUtFV09SRCgyLCAyKSwgJndzYURhdGEpOwogCQlpZiAoZXJyICE9IDApCkBA IC0zMTQsMjAgKzM0MSwyMSBAQCBhcmNoaXZlX2Nsb3NlX2Nvbm5lY3Rpb24oaW50IGNvZGUs IHZvaWQgKmFyZykKIAkJZWxzZQogCQl7CiAJCQkvKgotCQkJICogV2UncmUgYSB3b3JrZXIu ICBTaHV0IGRvd24gb3VyIG93biBEQiBjb25uZWN0aW9uIGlmIGFueS4gIE9uCi0JCQkgKiBX aW5kb3dzLCB3ZSBhbHNvIGhhdmUgdG8gY2xvc2Ugb3VyIGNvbW11bmljYXRpb24gc29ja2V0 cywgdG8KLQkJCSAqIGVtdWxhdGUgd2hhdCB3aWxsIGhhcHBlbiBvbiBVbml4IHdoZW4gdGhl IHdvcmtlciBwcm9jZXNzIGV4aXRzLgotCQkJICogKFdpdGhvdXQgdGhpcywgaWYgdGhpcyBp cyBhIHByZW1hdHVyZSBleGl0LCB0aGUgbGVhZGVyIHdvdWxkCi0JCQkgKiBmYWlsIHRvIGRl dGVjdCBpdCBiZWNhdXNlIHRoZXJlIHdvdWxkIGJlIG5vIEVPRiBjb25kaXRpb24gb24KLQkJ CSAqIHRoZSBvdGhlciBlbmQgb2YgdGhlIHBpcGUuKQorCQkJICogV2UncmUgYSB3b3JrZXIu ICBTaHV0IGRvd24gb3VyIG93biBEQiBjb25uZWN0aW9uIGlmIGFueS4KIAkJCSAqLwogCQkJ aWYgKHNsb3QtPkFIKQogCQkJCURpc2Nvbm5lY3REYXRhYmFzZSgmKHNsb3QtPkFILT5wdWJs aWMpKTsKIAotI2lmZGVmIFdJTjMyCi0JCQljbG9zZXNvY2tldChzbG90LT5waXBlUmV2UmVh ZCk7Ci0JCQljbG9zZXNvY2tldChzbG90LT5waXBlUmV2V3JpdGUpOwotI2VuZGlmCisJCQkv KgorCQkJICogVGVsbCB0aGUgbGVhZGVyIHdlJ3JlIGdvbmUgc28gaXQgc3RvcHMgd2FpdGlu ZyBmb3Igb3VyIHJlcGx5LiAgT24KKwkJCSAqIFVuaXggdGhlIHdvcmtlcidzIGV4aXQgY2xv c2VzIHRoZSBwaXBlIGFuZCB0aGUgbGVhZGVyIHNlZXMgRU9GOworCQkJICogdGhlIGNoYW5u ZWwgaGFzIG5vIEVPRiwgYW5kIGV4aXRfbmljZWx5KCkgZW5kcyBvbmx5IHRoaXMgdGhyZWFk LAorCQkJICogc28gc2lnbmFsIGl0IGhlcmUuCisJCQkgKi8KKwkJCUVudGVyQ3JpdGljYWxT ZWN0aW9uKCZtc2dfbG9jayk7CisJCQlzbG90LT53b3JrZXJEaWVkID0gdHJ1ZTsKKwkJCVdh a2VBbGxDb25kaXRpb25WYXJpYWJsZSgmbGVhZGVyX2N2KTsKKwkJCUxlYXZlQ3JpdGljYWxT ZWN0aW9uKCZtc2dfbG9jayk7CiAJCX0KIAl9CiAJZWxzZQpAQCAtMzUxLDYgKzM3OSwxNyBA QCBTaHV0ZG93bldvcmtlcnNIYXJkKFBhcmFsbGVsU3RhdGUgKnBzdGF0ZSkKIHsKIAlpbnQJ CQlpOwogCisJLyoKKwkgKiBUZWxsIGFueSB3b3JrZXJzIHRoYXQgYXJlIHdhaXRpbmcgZm9y IGNvbW1hbmRzIHRoYXQgdGhleSBjYW4gZXhpdC4KKwkgKi8KKyNpZmRlZiBXSU4zMgorCUVu dGVyQ3JpdGljYWxTZWN0aW9uKCZtc2dfbG9jayk7CisJZm9yIChpID0gMDsgaSA8IHBzdGF0 ZS0+bnVtV29ya2VyczsgaSsrKQorCQlwc3RhdGUtPnBhcmFsbGVsU2xvdFtpXS5jaGFuQ2xv c2VkID0gdHJ1ZTsKKwlXYWtlQWxsQ29uZGl0aW9uVmFyaWFibGUoJndvcmtlcl9jdik7CisJ TGVhdmVDcml0aWNhbFNlY3Rpb24oJm1zZ19sb2NrKTsKKyNlbHNlCisKIAkvKgogCSAqIENs b3NlIG91ciB3cml0ZSBlbmQgb2YgdGhlIHNvY2tldHMgc28gdGhhdCBhbnkgd29ya2VycyB3 YWl0aW5nIGZvcgogCSAqIGNvbW1hbmRzIGtub3cgdGhleSBjYW4gZXhpdC4gIChOb3RlOiBz b21lIG9mIHRoZSBwaXBlV3JpdGUgZmllbGRzIG1pZ2h0CkBAIC0zNTksNiArMzk4LDcgQEAg U2h1dGRvd25Xb3JrZXJzSGFyZChQYXJhbGxlbFN0YXRlICpwc3RhdGUpCiAJICovCiAJZm9y IChpID0gMDsgaSA8IHBzdGF0ZS0+bnVtV29ya2VyczsgaSsrKQogCQljbG9zZXNvY2tldChw c3RhdGUtPnBhcmFsbGVsU2xvdFtpXS5waXBlV3JpdGUpOworI2VuZGlmCiAKIAkvKgogCSAq IEZvcmNlIGVhcmx5IHRlcm1pbmF0aW9uIG9mIGFueSBjb21tYW5kcyBjdXJyZW50bHkgaW4g cHJvZ3Jlc3MuCkBAIC03ODMsMTIgKzgyMyw2IEBAIHNldF9jYW5jZWxfc2xvdF9hcmNoaXZl KFBhcmFsbGVsU2xvdCAqc2xvdCwgQXJjaGl2ZUhhbmRsZSAqQUgpCiBzdGF0aWMgdm9pZAog UnVuV29ya2VyKEFyY2hpdmVIYW5kbGUgKkFILCBQYXJhbGxlbFNsb3QgKnNsb3QpCiB7Ci0J aW50CQkJcGlwZWZkWzJdOwotCi0JLyogZmV0Y2ggY2hpbGQgZW5kcyBvZiBwaXBlcyAqLwot CXBpcGVmZFtQSVBFX1JFQURdID0gc2xvdC0+cGlwZVJldlJlYWQ7Ci0JcGlwZWZkW1BJUEVf V1JJVEVdID0gc2xvdC0+cGlwZVJldldyaXRlOwotCiAJLyoKIAkgKiBDbG9uZSB0aGUgYXJj aGl2ZSBzbyB0aGF0IHdlIGhhdmUgb3VyIG93biBzdGF0ZSB0byB3b3JrIHdpdGgsIGFuZCBp bgogCSAqIHBhcnRpY3VsYXIgb3VyIG93biBkYXRhYmFzZSBjb25uZWN0aW9uLgpAQCAtODEx LDcgKzg0NSw3IEBAIFJ1bldvcmtlcihBcmNoaXZlSGFuZGxlICpBSCwgUGFyYWxsZWxTbG90 ICpzbG90KQogCS8qCiAJICogRXhlY3V0ZSBjb21tYW5kcyB1bnRpbCBkb25lLgogCSAqLwot CVdhaXRGb3JDb21tYW5kcyhBSCwgcGlwZWZkKTsKKwlXYWl0Rm9yQ29tbWFuZHMoQUgsIHNs b3QpOwogCiAJLyoKIAkgKiBEaXNjb25uZWN0IGZyb20gZGF0YWJhc2UgYW5kIGNsZWFuIHVw LgpAQCAtODM0LDYgKzg2OCwxNSBAQCBpbml0X3NwYXduZWRfd29ya2VyX3dpbjMyKFdvcmtl ckluZm8gKndpKQogCS8qIERvbid0IG5lZWQgV29ya2VySW5mbyBhbnltb3JlICovCiAJZnJl ZSh3aSk7CiAKKwkvKgorCSAqIFJlY29yZCBvdXIgdGhyZWFkIGlkIHNvIEdldE15UFNsb3Qo KSBjYW4gdGVsbCB1cyBmcm9tIHRoZSBsZWFkZXIuICBEbworCSAqIHRoaXMgYmVmb3JlIGFu eXRoaW5nIHRoYXQgbWlnaHQgY2FsbCBleGl0X25pY2VseSgpOiB0aGUgY2xlYW51cCBoYW5k bGVyCisJICogdXNlcyBHZXRNeVBTbG90KCksIGFuZCBtaXN0YWtpbmcgYSBmYWlsaW5nIHdv cmtlciBmb3IgdGhlIGxlYWRlcgorCSAqIGRlYWRsb2NrcyBzaHV0ZG93bi4gIFdlIGNhbid0 IHRydXN0IHRoZSBsZWFkZXIgdG8gaGF2ZSBzdG9yZWQgdGhlIGlkCisJICogZnJvbSBfYmVn aW50aHJlYWRleCgpIHlldCwgc2luY2UgdGhpcyB0aHJlYWQgbWF5IHJ1biBiZWZvcmUgdGhh dCByZXR1cm5zLgorCSAqLworCXNsb3QtPnRocmVhZElkID0gR2V0Q3VycmVudFRocmVhZElk KCk7CisKIAkvKiBSdW4gdGhlIHdvcmtlciAuLi4gKi8KIAlSdW5Xb3JrZXIoQUgsIHNsb3Qp OwogCkBAIC04OTksMTEgKzk0MiwxMiBAQCBQYXJhbGxlbEJhY2t1cFN0YXJ0KEFyY2hpdmVI YW5kbGUgKkFIKQogCQl1aW50cHRyX3QJaGFuZGxlOwogI2Vsc2UKIAkJcGlkX3QJCXBpZDsK LSNlbmRpZgotCQlQYXJhbGxlbFNsb3QgKnNsb3QgPSAmKHBzdGF0ZS0+cGFyYWxsZWxTbG90 W2ldKTsKIAkJaW50CQkJcGlwZU1XWzJdLAogCQkJCQlwaXBlV01bMl07CisjZW5kaWYKKwkJ UGFyYWxsZWxTbG90ICpzbG90ID0gJihwc3RhdGUtPnBhcmFsbGVsU2xvdFtpXSk7CiAKKyNp Zm5kZWYgV0lOMzIKIAkJLyogQ3JlYXRlIGNvbW11bmljYXRpb24gcGlwZXMgZm9yIHRoaXMg d29ya2VyICovCiAJCWlmIChwZ3BpcGUocGlwZU1XKSA8IDAgfHwgcGdwaXBlKHBpcGVXTSkg PCAwKQogCQkJcGdfZmF0YWwoImNvdWxkIG5vdCBjcmVhdGUgY29tbXVuaWNhdGlvbiBjaGFu bmVsczogJW0iKTsKQEAgLTkxNCw2ICs5NTgsNyBAQCBQYXJhbGxlbEJhY2t1cFN0YXJ0KEFy Y2hpdmVIYW5kbGUgKkFIKQogCQkvKiBjaGlsZCdzIGVuZHMgb2YgdGhlIHBpcGVzICovCiAJ CXNsb3QtPnBpcGVSZXZSZWFkID0gcGlwZU1XW1BJUEVfUkVBRF07CiAJCXNsb3QtPnBpcGVS ZXZXcml0ZSA9IHBpcGVXTVtQSVBFX1dSSVRFXTsKKyNlbmRpZgogCiAjaWZkZWYgV0lOMzIK IAkJLyogQ3JlYXRlIHRyYW5zaWVudCBzdHJ1Y3R1cmUgdG8gcGFzcyBhcmdzIHRvIHdvcmtl ciBmdW5jdGlvbiAqLwpAQCAtOTIyLDggKzk2NywxMyBAQCBQYXJhbGxlbEJhY2t1cFN0YXJ0 KEFyY2hpdmVIYW5kbGUgKkFIKQogCQl3aS0+QUggPSBBSDsKIAkJd2ktPnNsb3QgPSBzbG90 OwogCisJCS8qCisJCSAqIFRoZSB3b3JrZXIgc3RvcmVzIGl0cyBvd24gdGhyZWFkIGlkIChz ZWUgaW5pdF9zcGF3bmVkX3dvcmtlcl93aW4zMiksCisJCSAqIHNvIGRvbid0IGFzayBfYmVn aW50aHJlYWRleCgpIHRvIHJlcG9ydCBpdCAtLSB0aGF0IHdvdWxkIHJhY2UgaXRzCisJCSAq IHN0b3JlLgorCQkgKi8KIAkJaGFuZGxlID0gX2JlZ2ludGhyZWFkZXgoTlVMTCwgMCwgKHZv aWQgKikgJmluaXRfc3Bhd25lZF93b3JrZXJfd2luMzIsCi0JCQkJCQkJCXdpLCAwLCAmKHNs b3QtPnRocmVhZElkKSk7CisJCQkJCQkJCXdpLCAwLCBOVUxMKTsKIAkJaWYgKGhhbmRsZSA9 PSAwKQogCQkJcGdfZmF0YWwoImNvdWxkIG5vdCBjcmVhdGUgd29ya2VyIHRocmVhZDogJW0i KTsKIAkJc2xvdC0+aFRocmVhZCA9IGhhbmRsZTsKQEAgLTEwMTksMTIgKzEwNjksMjEgQEAg UGFyYWxsZWxCYWNrdXBFbmQoQXJjaGl2ZUhhbmRsZSAqQUgsIFBhcmFsbGVsU3RhdGUgKnBz dGF0ZSkKIAkvKiBUaGVyZSBzaG91bGQgbm90IGJlIGFueSB1bmZpbmlzaGVkIGpvYnMgKi8K IAlBc3NlcnQoSXNFdmVyeVdvcmtlcklkbGUocHN0YXRlKSk7CiAKKwkvKiBUZWxsIHRoZSB3 b3JrZXJzIHRoZXkgY2FuIGV4aXQgKi8KKyNpZmRlZiBXSU4zMgorCUVudGVyQ3JpdGljYWxT ZWN0aW9uKCZtc2dfbG9jayk7CisJZm9yIChpID0gMDsgaSA8IHBzdGF0ZS0+bnVtV29ya2Vy czsgaSsrKQorCQlwc3RhdGUtPnBhcmFsbGVsU2xvdFtpXS5jaGFuQ2xvc2VkID0gdHJ1ZTsK KwlXYWtlQWxsQ29uZGl0aW9uVmFyaWFibGUoJndvcmtlcl9jdik7CisJTGVhdmVDcml0aWNh bFNlY3Rpb24oJm1zZ19sb2NrKTsKKyNlbHNlCiAJLyogQ2xvc2UgdGhlIHNvY2tldHMgc28g dGhhdCB0aGUgd29ya2VycyBrbm93IHRoZXkgY2FuIGV4aXQgKi8KIAlmb3IgKGkgPSAwOyBp IDwgcHN0YXRlLT5udW1Xb3JrZXJzOyBpKyspCiAJewogCQljbG9zZXNvY2tldChwc3RhdGUt PnBhcmFsbGVsU2xvdFtpXS5waXBlUmVhZCk7CiAJCWNsb3Nlc29ja2V0KHBzdGF0ZS0+cGFy YWxsZWxTbG90W2ldLnBpcGVXcml0ZSk7CiAJfQorI2VuZGlmCiAKIAkvKiBXYWl0IGZvciB0 aGVtIHRvIGV4aXQgKi8KIAlXYWl0Rm9yVGVybWluYXRpbmdXb3JrZXJzKHBzdGF0ZSk7CkBA IC0xMjg1LDcgKzEzNDQsNyBAQCBsb2NrVGFibGVGb3JXb3JrZXIoQXJjaGl2ZUhhbmRsZSAq QUgsIFRvY0VudHJ5ICp0ZSkKICAqIFJlYWQgYW5kIGV4ZWN1dGUgY29tbWFuZHMgZnJvbSB0 aGUgbGVhZGVyIHVudGlsIHdlIHNlZSBFT0Ygb24gdGhlIHBpcGUuCiAgKi8KIHN0YXRpYyB2 b2lkCi1XYWl0Rm9yQ29tbWFuZHMoQXJjaGl2ZUhhbmRsZSAqQUgsIGludCBwaXBlZmRbMl0p CitXYWl0Rm9yQ29tbWFuZHMoQXJjaGl2ZUhhbmRsZSAqQUgsIFBhcmFsbGVsU2xvdCAqc2xv dCkKIHsKIAljaGFyCSAgICpjb21tYW5kOwogCVRvY0VudHJ5ICAgKnRlOwpAQCAtMTI5NSw3 ICsxMzU0LDcgQEAgV2FpdEZvckNvbW1hbmRzKEFyY2hpdmVIYW5kbGUgKkFILCBpbnQgcGlw ZWZkWzJdKQogCiAJZm9yICg7OykKIAl7Ci0JCWlmICghKGNvbW1hbmQgPSBnZXRNZXNzYWdl RnJvbUxlYWRlcihwaXBlZmQpKSkKKwkJaWYgKCEoY29tbWFuZCA9IGdldE1lc3NhZ2VGcm9t TGVhZGVyKHNsb3QpKSkKIAkJewogCQkJLyogRU9GLCBzbyBkb25lICovCiAJCQlyZXR1cm47 CkBAIC0xMzIzLDcgKzEzODIsNyBAQCBXYWl0Rm9yQ29tbWFuZHMoQXJjaGl2ZUhhbmRsZSAq QUgsIGludCBwaXBlZmRbMl0pCiAJCS8qIFJldHVybiBzdGF0dXMgdG8gbGVhZGVyICovCiAJ CWJ1aWxkV29ya2VyUmVzcG9uc2UoQUgsIHRlLCBhY3QsIHN0YXR1cywgYnVmLCBzaXplb2Yo YnVmKSk7CiAKLQkJc2VuZE1lc3NhZ2VUb0xlYWRlcihwaXBlZmQsIGJ1Zik7CisJCXNlbmRN ZXNzYWdlVG9MZWFkZXIoc2xvdCwgYnVmKTsKIAogCQkvKiBjb21tYW5kIHdhcyBwZ19tYWxs b2MnZCBhbmQgd2UgYXJlIHJlc3BvbnNpYmxlIGZvciBmcmVlKClpbmcgaXQuICovCiAJCWZy ZWUoY29tbWFuZCk7CkBAIC0xNDY1LDkgKzE1MjQsMjEgQEAgV2FpdEZvcldvcmtlcnMoQXJj aGl2ZUhhbmRsZSAqQUgsIFBhcmFsbGVsU3RhdGUgKnBzdGF0ZSwgV0ZXX1dhaXRPcHRpb24g bW9kZSkKICAqIFRoaXMgZnVuY3Rpb24gaXMgZXhlY3V0ZWQgaW4gd29ya2VyIHByb2Nlc3Nl cy4KICAqLwogc3RhdGljIGNoYXIgKgotZ2V0TWVzc2FnZUZyb21MZWFkZXIoaW50IHBpcGVm ZFsyXSkKK2dldE1lc3NhZ2VGcm9tTGVhZGVyKFBhcmFsbGVsU2xvdCAqc2xvdCkKIHsKLQly ZXR1cm4gcmVhZE1lc3NhZ2VGcm9tUGlwZShwaXBlZmRbUElQRV9SRUFEXSk7CisjaWZkZWYg V0lOMzIKKwljaGFyCSAgICptc2c7CisKKwlFbnRlckNyaXRpY2FsU2VjdGlvbigmbXNnX2xv Y2spOworCXdoaWxlIChzbG90LT5jbWRNc2cgPT0gTlVMTCAmJiAhc2xvdC0+Y2hhbkNsb3Nl ZCkKKwkJU2xlZXBDb25kaXRpb25WYXJpYWJsZUNTKCZ3b3JrZXJfY3YsICZtc2dfbG9jaywg SU5GSU5JVEUpOworCW1zZyA9IHNsb3QtPmNtZE1zZzsJCQkvKiBOVUxMIGhlcmUgbWVhbnMg dGhlIGNoYW5uZWwgd2FzIGNsb3NlZCAqLworCXNsb3QtPmNtZE1zZyA9IE5VTEw7CisJTGVh dmVDcml0aWNhbFNlY3Rpb24oJm1zZ19sb2NrKTsKKwlyZXR1cm4gbXNnOworI2Vsc2UKKwly ZXR1cm4gcmVhZE1lc3NhZ2VGcm9tUGlwZShzbG90LT5waXBlUmV2UmVhZCk7CisjZW5kaWYK IH0KIAogLyoKQEAgLTE0NzYsMTIgKzE1NDcsMjAgQEAgZ2V0TWVzc2FnZUZyb21MZWFkZXIo aW50IHBpcGVmZFsyXSkKICAqIFRoaXMgZnVuY3Rpb24gaXMgZXhlY3V0ZWQgaW4gd29ya2Vy IHByb2Nlc3Nlcy4KICAqLwogc3RhdGljIHZvaWQKLXNlbmRNZXNzYWdlVG9MZWFkZXIoaW50 IHBpcGVmZFsyXSwgY29uc3QgY2hhciAqc3RyKQorc2VuZE1lc3NhZ2VUb0xlYWRlcihQYXJh bGxlbFNsb3QgKnNsb3QsIGNvbnN0IGNoYXIgKnN0cikKIHsKKyNpZmRlZiBXSU4zMgorCUVu dGVyQ3JpdGljYWxTZWN0aW9uKCZtc2dfbG9jayk7CisJQXNzZXJ0KHNsb3QtPnJlc3BNc2cg PT0gTlVMTCk7CisJc2xvdC0+cmVzcE1zZyA9IHBnX3N0cmR1cChzdHIpOworCVdha2VBbGxD b25kaXRpb25WYXJpYWJsZSgmbGVhZGVyX2N2KTsKKwlMZWF2ZUNyaXRpY2FsU2VjdGlvbigm bXNnX2xvY2spOworI2Vsc2UKIAlpbnQJCQlsZW4gPSBzdHJsZW4oc3RyKSArIDE7CiAKLQlp ZiAocGlwZXdyaXRlKHBpcGVmZFtQSVBFX1dSSVRFXSwgc3RyLCBsZW4pICE9IGxlbikKKwlp ZiAocGlwZXdyaXRlKHNsb3QtPnBpcGVSZXZXcml0ZSwgc3RyLCBsZW4pICE9IGxlbikKIAkJ cGdfZmF0YWwoImNvdWxkIG5vdCB3cml0ZSB0byB0aGUgY29tbXVuaWNhdGlvbiBjaGFubmVs OiAlbSIpOworI2VuZGlmCiB9CiAKIC8qCkBAIC0xNTMwLDYgKzE2MDksNTMgQEAgc2VsZWN0 X2xvb3AoaW50IG1heEZkLCBmZF9zZXQgKndvcmtlcnNldCkKIHN0YXRpYyBjaGFyICoKIGdl dE1lc3NhZ2VGcm9tV29ya2VyKFBhcmFsbGVsU3RhdGUgKnBzdGF0ZSwgYm9vbCBkb193YWl0 LCBpbnQgKndvcmtlcikKIHsKKyNpZmRlZiBXSU4zMgorCWludAkJCWk7CisKKwkvKgorCSAq IFJldHVybiB0aGUgZmlyc3QgcGVuZGluZyByZXNwb25zZTsgaWYgbm9uZSBhbmQgZG9fd2Fp dCwgc2xlZXAgb24KKwkgKiBsZWFkZXJfY3YgdW50aWwgYSB3b3JrZXIgcG9zdHMgb25lLgor CSAqLworCUVudGVyQ3JpdGljYWxTZWN0aW9uKCZtc2dfbG9jayk7CisJZm9yICg7OykKKwl7 CisJCWJvb2wJCWFueURpZWQgPSBmYWxzZTsKKworCQlmb3IgKGkgPSAwOyBpIDwgcHN0YXRl LT5udW1Xb3JrZXJzOyBpKyspCisJCXsKKwkJCWNoYXIJICAgKm1zZzsKKworCQkJaWYgKCFX T1JLRVJfSVNfUlVOTklORyhwc3RhdGUtPnBhcmFsbGVsU2xvdFtpXS53b3JrZXJTdGF0dXMp KQorCQkJCWNvbnRpbnVlOworCQkJbXNnID0gcHN0YXRlLT5wYXJhbGxlbFNsb3RbaV0ucmVz cE1zZzsKKwkJCWlmIChtc2cgIT0gTlVMTCkKKwkJCXsKKwkJCQlwc3RhdGUtPnBhcmFsbGVs U2xvdFtpXS5yZXNwTXNnID0gTlVMTDsKKwkJCQlMZWF2ZUNyaXRpY2FsU2VjdGlvbigmbXNn X2xvY2spOworCQkJCSp3b3JrZXIgPSBpOworCQkJCXJldHVybiBtc2c7CisJCQl9CisJCQlp ZiAocHN0YXRlLT5wYXJhbGxlbFNsb3RbaV0ud29ya2VyRGllZCkKKwkJCQlhbnlEaWVkID0g dHJ1ZTsKKwkJfQorCisJCS8qCisJCSAqIEEgd29ya2VyIGRpZWQgd2l0aG91dCByZXNwb25k aW5nOiByZXR1cm4gTlVMTCBhcyB0aGUgVW5peCBwYXRoIGRvZXMKKwkJICogb24gRU9GLCBz byB0aGUgY2FsbGVyIHJlcG9ydHMgdGhlIGZhaWx1cmUgaW5zdGVhZCBvZiBoYW5naW5nLgor CQkgKi8KKwkJaWYgKGFueURpZWQpCisJCXsKKwkJCUxlYXZlQ3JpdGljYWxTZWN0aW9uKCZt c2dfbG9jayk7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCQlpZiAoIWRvX3dhaXQpCisJCXsK KwkJCUxlYXZlQ3JpdGljYWxTZWN0aW9uKCZtc2dfbG9jayk7CisJCQlyZXR1cm4gTlVMTDsK KwkJfQorCQlTbGVlcENvbmRpdGlvblZhcmlhYmxlQ1MoJmxlYWRlcl9jdiwgJm1zZ19sb2Nr LCBJTkZJTklURSk7CisJfQorI2Vsc2UKIAlpbnQJCQlpOwogCWZkX3NldAkJd29ya2Vyc2V0 OwogCWludAkJCW1heEZkID0gLTE7CkBAIC0xNTg1LDYgKzE3MTEsNyBAQCBnZXRNZXNzYWdl RnJvbVdvcmtlcihQYXJhbGxlbFN0YXRlICpwc3RhdGUsIGJvb2wgZG9fd2FpdCwgaW50ICp3 b3JrZXIpCiAJfQogCUFzc2VydChmYWxzZSk7CiAJcmV0dXJuIE5VTEw7CisjZW5kaWYKIH0K IAogLyoKQEAgLTE1OTUsMTIgKzE3MjIsMjIgQEAgZ2V0TWVzc2FnZUZyb21Xb3JrZXIoUGFy YWxsZWxTdGF0ZSAqcHN0YXRlLCBib29sIGRvX3dhaXQsIGludCAqd29ya2VyKQogc3RhdGlj IHZvaWQKIHNlbmRNZXNzYWdlVG9Xb3JrZXIoUGFyYWxsZWxTdGF0ZSAqcHN0YXRlLCBpbnQg d29ya2VyLCBjb25zdCBjaGFyICpzdHIpCiB7CisjaWZkZWYgV0lOMzIKKwlQYXJhbGxlbFNs b3QgKnNsb3QgPSAmcHN0YXRlLT5wYXJhbGxlbFNsb3Rbd29ya2VyXTsKKworCUVudGVyQ3Jp dGljYWxTZWN0aW9uKCZtc2dfbG9jayk7CisJQXNzZXJ0KHNsb3QtPmNtZE1zZyA9PSBOVUxM KTsKKwlzbG90LT5jbWRNc2cgPSBwZ19zdHJkdXAoc3RyKTsKKwlXYWtlQWxsQ29uZGl0aW9u VmFyaWFibGUoJndvcmtlcl9jdik7CisJTGVhdmVDcml0aWNhbFNlY3Rpb24oJm1zZ19sb2Nr KTsKKyNlbHNlCiAJaW50CQkJbGVuID0gc3RybGVuKHN0cikgKyAxOwogCiAJaWYgKHBpcGV3 cml0ZShwc3RhdGUtPnBhcmFsbGVsU2xvdFt3b3JrZXJdLnBpcGVXcml0ZSwgc3RyLCBsZW4p ICE9IGxlbikKIAl7CiAJCXBnX2ZhdGFsKCJjb3VsZCBub3Qgd3JpdGUgdG8gdGhlIGNvbW11 bmljYXRpb24gY2hhbm5lbDogJW0iKTsKIAl9CisjZW5kaWYKIH0KIAogLyoKLS0gCjIuNTQu MC53aW5kb3dzLjEKCg== --------------yEwnwzcggiNX0fD93pGfk8bz Content-Type: text/plain; charset=UTF-8; name="v1-0004-pg_dump-allow-more-than-64-parallel-jobs-on-Windo.patch" Content-Disposition: attachment; filename*0="v1-0004-pg_dump-allow-more-than-64-parallel-jobs-on-Windo.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSA3ZmFmOTVlYzk3Y2YxMjI4Njc0MzM4ZGI5Y2YxNTY1ZDhjYTIzNmVkIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBCcnlhbiBHcmVlbiA8ZGJyeWFuLmdyZWVuQGdtYWls LmNvbT4KRGF0ZTogU3VuLCAyOCBKdW4gMjAyNiAxMzoyNDoyOCAtMDUwMApTdWJqZWN0OiBb UEFUQ0ggdjEgNC80XSBwZ19kdW1wOiBhbGxvdyBtb3JlIHRoYW4gNjQgcGFyYWxsZWwgam9i cyBvbiBXaW5kb3dzCgpUaGUgV2luZG93cyB3b3JrZXIgam9pbiBwYXNzZWQgZXZlcnkgcnVu bmluZyB3b3JrZXIncyBoYW5kbGUgdG8gb25lCldhaXRGb3JNdWx0aXBsZU9iamVjdHMoKSBj YWxsLCB3aGljaCB3YWl0cyBvbiBhdCBtb3N0Ck1BWElNVU1fV0FJVF9PQkpFQ1RTICg2NCku ICBUaGF0IGNhcHBlZCBQR19NQVhfSk9CUyBhdCA2NCBvbiBXaW5kb3dzLgpXaXRoIGRpc3Bh dGNoIG5vIGxvbmdlciB1c2luZyBzZWxlY3QoKS9GRF9TRVRTSVpFLCB0aGlzIHdhcyB0aGUg bGFzdAp0aGluZyBmb3JjaW5nIHRoZSBsaW1pdC4KCldhaXQgb24gYXQgbW9zdCBNQVhJTVVN X1dBSVRfT0JKRUNUUyBoYW5kbGVzIHBlciBpdGVyYXRpb24uICBPbmUgd29ya2VyCmlzIHJl YXBlZCBwZXIgaXRlcmF0aW9uIGFuZCB0aGUgaGFuZGxlIHNldCBpcyByZWJ1aWx0IGZyb20g dGhvc2Ugc3RpbGwKcnVubmluZywgc28gd29ya2VycyBwYXN0IHRoZSBmaXJzdCBiYXRjaCBh cmUgY2F1Z2h0IG9uIGxhdGVyIHBhc3NlczsKdGhpcyBpcyBzYWZlIGJlY2F1c2UgZXZlcnkg d29ya2VyIGhhcyBiZWVuIHRvbGQgdG8gZXhpdCBiZWZvcmUgdGhlIHdhaXQKYmVnaW5zLiAg UmFpc2UgUEdfTUFYX0pPQlMgdG8gSU5UX01BWCBvbiBhbGwgcGxhdGZvcm1zLgotLS0KIHNy Yy9iaW4vcGdfZHVtcC9wYXJhbGxlbC5jIHwgMTIgKysrKysrKysrLS0tCiBzcmMvYmluL3Bn X2R1bXAvcGFyYWxsZWwuaCB8ICA4IC0tLS0tLS0tCiAyIGZpbGVzIGNoYW5nZWQsIDkgaW5z ZXJ0aW9ucygrKSwgMTEgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2Jpbi9wZ19k dW1wL3BhcmFsbGVsLmMgYi9zcmMvYmluL3BnX2R1bXAvcGFyYWxsZWwuYwppbmRleCA1NTJh OGMxNDllLi5kOThhZTcwODgzIDEwMDY0NAotLS0gYS9zcmMvYmluL3BnX2R1bXAvcGFyYWxs ZWwuYworKysgYi9zcmMvYmluL3BnX2R1bXAvcGFyYWxsZWwuYwpAQCAtNDYxLDEzICs0NjEs MTkgQEAgV2FpdEZvclRlcm1pbmF0aW5nV29ya2VycyhQYXJhbGxlbFN0YXRlICpwc3RhdGUp CiAJCQl9CiAJCX0KICNlbHNlCQkJCQkJCS8qIFdJTjMyICovCi0JCS8qIE9uIFdpbmRvd3Ms IHdlIG11c3QgdXNlIFdhaXRGb3JNdWx0aXBsZU9iamVjdHMoKSAqLwotCQlIQU5ETEUJICAg KmxwSGFuZGxlcyA9IHBnX21hbGxvY19hcnJheShIQU5ETEUsIHBzdGF0ZS0+bnVtV29ya2Vy cyk7CisKKwkJLyoKKwkJICogV2FpdEZvck11bHRpcGxlT2JqZWN0cygpIHdhaXRzIG9uIGF0 IG1vc3QgTUFYSU1VTV9XQUlUX09CSkVDVFMKKwkJICogaGFuZGxlcy4gIFdhdGNoIHRoZSBm aXJzdCBiYXRjaDsgd2UgcmVhcCBvbmUgcGVyIGl0ZXJhdGlvbiBhbmQKKwkJICogcmVzY2Fu LCBzbyBhbnkgYmV5b25kIGl0IGFyZSBjYXVnaHQgb24gbGF0ZXIgcGFzc2VzLiAgU2FmZSBi ZWNhdXNlCisJCSAqIGV2ZXJ5IHdvcmtlciBoYXMgYWxyZWFkeSBiZWVuIHRvbGQgdG8gZXhp dC4KKwkJICovCisJCUhBTkRMRQkgICAqbHBIYW5kbGVzID0gcGdfbWFsbG9jX2FycmF5KEhB TkRMRSwgTUFYSU1VTV9XQUlUX09CSkVDVFMpOwogCQlpbnQJCQlucnVuID0gMDsKIAkJRFdP UkQJCXJldDsKIAkJdWludHB0cl90CWhUaHJlYWQ7CiAKLQkJZm9yIChqID0gMDsgaiA8IHBz dGF0ZS0+bnVtV29ya2VyczsgaisrKQorCQlmb3IgKGogPSAwOyBqIDwgcHN0YXRlLT5udW1X b3JrZXJzICYmIG5ydW4gPCBNQVhJTVVNX1dBSVRfT0JKRUNUUzsgaisrKQogCQl7CiAJCQlp ZiAoV09SS0VSX0lTX1JVTk5JTkcocHN0YXRlLT5wYXJhbGxlbFNsb3Rbal0ud29ya2VyU3Rh dHVzKSkKIAkJCXsKZGlmZiAtLWdpdCBhL3NyYy9iaW4vcGdfZHVtcC9wYXJhbGxlbC5oIGIv c3JjL2Jpbi9wZ19kdW1wL3BhcmFsbGVsLmgKaW5kZXggZjc1NTdjZDA4OS4uNTc1NGUxM2Vh YSAxMDA2NDQKLS0tIGEvc3JjL2Jpbi9wZ19kdW1wL3BhcmFsbGVsLmgKKysrIGIvc3JjL2Jp bi9wZ19kdW1wL3BhcmFsbGVsLmgKQEAgLTM3LDE2ICszNyw4IEBAIHR5cGVkZWYgZW51bQog CiAvKgogICogTWF4aW11bSBudW1iZXIgb2YgcGFyYWxsZWwgam9icyBhbGxvd2VkLgotICoK LSAqIE9uIFdpbmRvd3Mgd2UgY2FuIG9ubHkgaGF2ZSBhdCBtb3N0IE1BWElNVU1fV0FJVF9P QkpFQ1RTICg9IDY0IHVzdWFsbHkpCi0gKiBwYXJhbGxlbCBqb2JzIGJlY2F1c2UgdGhhdCdz IHRoZSBtYXhpbXVtIGxpbWl0IGZvciB0aGUKLSAqIFdhaXRGb3JNdWx0aXBsZU9iamVjdHMo KSBjYWxsLgogICovCi0jaWZkZWYgV0lOMzIKLSNkZWZpbmUgUEdfTUFYX0pPQlMgTUFYSU1V TV9XQUlUX09CSkVDVFMKLSNlbHNlCiAjZGVmaW5lIFBHX01BWF9KT0JTIElOVF9NQVgKLSNl bmRpZgogCiAvKiBQYXJhbGxlbFNsb3QgaXMgYW4gb3BhcXVlIHN0cnVjdCBrbm93biBvbmx5 IHdpdGhpbiBwYXJhbGxlbC5jICovCiB0eXBlZGVmIHN0cnVjdCBQYXJhbGxlbFNsb3QgUGFy YWxsZWxTbG90OwotLSAKMi41NC4wLndpbmRvd3MuMQoK --------------yEwnwzcggiNX0fD93pGfk8bz--