From unknown Sat Jun 14 19:12:50 2025 X-Loop: help-debbugs@gnu.org Subject: bug#9488: 23.2; `call-process' races with SIGCHLD handler Resent-From: Taylor R Campbell Original-Sender: debbugs-submit-bounces@debbugs.gnu.org Resent-To: owner@debbugs.gnu.org Resent-CC: bug-gnu-emacs@gnu.org Resent-Date: Mon, 12 Sep 2011 20:28:02 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: report 9488 X-GNU-PR-Package: emacs X-GNU-PR-Keywords: To: 9488@debbugs.gnu.org X-Debbugs-Original-To: bug-gnu-emacs@gnu.org Received: via spool by submit@debbugs.gnu.org id=B.131585924523411 (code B ref -1); Mon, 12 Sep 2011 20:28:02 +0000 Received: (at submit) by debbugs.gnu.org; 12 Sep 2011 20:27:25 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1R3D6C-00065X-LH for submit@debbugs.gnu.org; Mon, 12 Sep 2011 16:27:25 -0400 Received: from eggs.gnu.org ([140.186.70.92]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1R3D1Y-0005yy-9R for submit@debbugs.gnu.org; Mon, 12 Sep 2011 16:22:37 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1R3CxH-0005nH-36 for submit@debbugs.gnu.org; Mon, 12 Sep 2011 16:18:13 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-3.1 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_LOW, RP_MATCHES_RCVD autolearn=unavailable version=3.3.1 Received: from lists.gnu.org ([140.186.70.17]:34370) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1R3CxH-0005nD-1h for submit@debbugs.gnu.org; Mon, 12 Sep 2011 16:18:11 -0400 Received: from eggs.gnu.org ([140.186.70.92]:41839) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1R3CxG-0005mo-3j for bug-gnu-emacs@gnu.org; Mon, 12 Sep 2011 16:18:10 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1R3CxE-0005mj-QC for bug-gnu-emacs@gnu.org; Mon, 12 Sep 2011 16:18:10 -0400 Received: from pluto.mumble.net ([206.123.75.20]:42164) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1R3CxE-0005mG-Ke for bug-gnu-emacs@gnu.org; Mon, 12 Sep 2011 16:18:08 -0400 Received: by pluto.mumble.net (Postfix, from userid 1014) id 19D3EE4057; Mon, 12 Sep 2011 20:18:04 +0000 (UTC) From: Taylor R Campbell Date: Mon, 12 Sep 2011 20:14:11 +0000 User-Agent: IMAIL/1.21; Edwin/3.116; MIT-Scheme/9.1 MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit Message-Id: <20110912201804.19D3EE4057@pluto.mumble.net> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6 (newer, 3) X-Received-From: 140.186.70.17 X-Spam-Score: -6.6 (------) X-Mailman-Approved-At: Mon, 12 Sep 2011 16:27:24 -0400 X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -6.6 (------) `call-process' relies on `wait_for_termination' to block until the SIGCHLD handler has run for the synchronous subprocess. But this is not the condition that `wait_for_termination' guarantees on exit. Rather, if `wait_for_termination' returns, then either (a) there is no process having the same pid as the child had, or (b) a SIGCHLD has been delivered. If the subprocess has died, but no SIGCHLD has been delivered yet, then `wait_for_termination' may return even though the SIGCHLD handler has yet to run. As an aside, these conditions are not sufficient for `wait_for_termination' to return: it may block indefinitely if the operating system has already delivered SIGCHLD and reused the pid before control enters `wait_for_termination'. I have not observed indefinite blocking behaviour in practice, but only because pids don't get reused very fast. What I have observed is process exit values of 0 that should have been nonzero on GNU Emacs 23.2.1 (i386--netbsdelf, X toolkit) of 2011-03-02. I noticed this because `M-x grep' sometimes prompts me with `grep -nH' and sometimes with `grep -nH -e', in turn because (call-process "grep" nil nil nil "-e" "/dev/null") sometimes returns 0 and sometimes returns 1 depending on who wins the race. I have not tested newer versions of GNU Emacs, but a cursory glance at the code suggests that while the relevant subprocess code has grown more unmaintainably complicated, the problem persists. From unknown Sat Jun 14 19:12:50 2025 X-Loop: help-debbugs@gnu.org Subject: bug#9488: 24.3.50; Zombie process left after call-process References: <20110912201804.19D3EE4057@pluto.mumble.net> In-Reply-To: <20110912201804.19D3EE4057@pluto.mumble.net> Resent-From: Paul Eggert Original-Sender: debbugs-submit-bounces@debbugs.gnu.org Resent-CC: bug-gnu-emacs@gnu.org Resent-Date: Mon, 26 Nov 2012 22:41:02 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 9488 X-GNU-PR-Package: emacs X-GNU-PR-Keywords: To: Harald Hanche-Olsen Cc: 9488@debbugs.gnu.org, Eli Zaretskii , 12980@debbugs.gnu.org Received: via spool by 9488-submit@debbugs.gnu.org id=B9488.13539696393260 (code B ref 9488); Mon, 26 Nov 2012 22:41:02 +0000 Received: (at 9488) by debbugs.gnu.org; 26 Nov 2012 22:40:39 +0000 Received: from localhost ([127.0.0.1]:40651 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Td7Lw-0000qT-PR for submit@debbugs.gnu.org; Mon, 26 Nov 2012 17:40:39 -0500 Received: from smtp.cs.ucla.edu ([131.179.128.62]:37038) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Td7Lp-0000q7-GG; Mon, 26 Nov 2012 17:40:32 -0500 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 1ABF0A60003; Mon, 26 Nov 2012 14:38:44 -0800 (PST) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id t3XDpJByLnOC; Mon, 26 Nov 2012 14:38:42 -0800 (PST) Received: from penguin.cs.ucla.edu (Penguin.CS.UCLA.EDU [131.179.64.200]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 9EC55A60001; Mon, 26 Nov 2012 14:38:42 -0800 (PST) Message-ID: <50B3EF71.3020805@cs.ucla.edu> Date: Mon, 26 Nov 2012 14:38:41 -0800 From: Paul Eggert User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/17.0 Thunderbird/17.0 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="------------040502050800060804060908" X-Spam-Score: -4.6 (----) X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -4.6 (----) This is a multi-part message in MIME format. --------------040502050800060804060908 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit Harald, thanks for the bug report. This part of Emacs is a bit messy, but I hacked away at it and came up with the attached proposed patch. This patch touches some code for Microsoft platforms so I'm CC'ing this to Eli. I'm also CC'ing Bug#9488 as I think it fixes the rest of that bug too. --------------040502050800060804060908 Content-Type: text/plain; charset=us-ascii; name="g_spawn_sync.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="g_spawn_sync.txt" PT09IG1vZGlmaWVkIGZpbGUgJ3NyYy9DaGFuZ2VMb2cnCi0tLSBzcmMvQ2hhbmdlTG9nCTIw MTItMTEtMjUgMDc6NTA6NTUgKzAwMDAKKysrIHNyYy9DaGFuZ2VMb2cJMjAxMi0xMS0yNiAy MjozNDo1OCArMDAwMApAQCAtMSwzICsxLDU1IEBACisyMDEyLTExLTI2ICBQYXVsIEVnZ2Vy dCAgPGVnZ2VydEBjcy51Y2xhLmVkdT4KKworCURvbid0IGxldCBjYWxsLXByb2Nlc3MgYmUg YSB6b21iaWUgZmFjdG9yeSAoQnVnIzEyOTgwKS4KKwlGaXhpbmcgdGhpcyBidWcgcmVxdWly ZWQgc29tZSBjbGVhbnVwIG9mIHRoZSBzaWduYWwtaGFuZGxpbmcgY29kZS4KKwlBcyBhIHNp ZGUgZWZmZWN0LCB0aGlzIGNoYW5nZSBhbHNvIGZpeGVzIGEgbG9uZ3N0YW5kaW5nIHJhcmUg cmFjZQorCWNvbmRpdGlvbiB3aGVyZWJ5IEVtYWNzIGNvdWxkIG1pc3Rha2VubHkga2lsbCB1 bnJlbGF0ZWQgcHJvY2Vzc2VzLAorCWFuZCBpdCBmaXhlcyBhIGJ1ZyB3aGVyZSBhIHNlY29u ZCBDLWcgZG9lcyBub3Qga2lsbCBhIHJlY2FsY2l0cmFudAorCXN5bmNocm9ub3VzIHByb2Nl c3MgaW4gR05VL0xpbnV4IGFuZCBzaW1pbGFyIHBsYXRmb3Jtcy4KKwlUaGUgcGF0Y2ggc2hv dWxkIGFsc28gZml4IHRoZSBsYXN0IHZlc3RpZ2VzIG9mIEJ1ZyM5NDg4LAorCWEgYnVnIHdo aWNoIGhhcyBtb3N0bHkgYmVlbiBmaXhlZCBvbiB0aGUgdHJ1bmsgYnkgb3RoZXIgY2hhbmdl cy4KKwkqIGNhbGxwcm9jLmMsIHByb2Nlc3MuaCAoc3luY2hfcHJvY2Vzc19hbGl2ZSwgc3lu Y2hfcHJvY2Vzc19kZWF0aCkKKwkoc3luY2hfcHJvY2Vzc190ZXJtc2lnLCBzeW5jX3Byb2Nl c3NfcmV0Y29kZSk6CisJUmVtb3ZlLiAgQWxsIHVzZXMgcmVtb3ZlZCwgdG8gc2ltcGxpZnkg YW5hbHlzaXMgYW5kIHNvIHRoYXQKKwlsZXNzIGNvbnNpbmcgaXMgZG9uZSBpbnNpZGUgY3Jp dGljYWwgc2VjdGlvbnMuCisJKiBjYWxscHJvYy5jIChyZWFwYWJsZV9jaGlsZCwgYmxvY2tf Y2hpbGRfc2lnbmFsLCB1bmJsb2NrX2NoaWxkX3NpZ25hbCk6CisJTmV3IGZ1bmN0aW9ucywg dG8gYXZvaWQgcmFjZXMgdGhhdCBjb3VsZCBraWxsIGlubm9jZW50LXZpY3RpbSBwcm9jZXNz ZXMuCisJKGNhbGxfcHJvY2Vzc19raWxsLCBjYWxsX3Byb2Nlc3NfY2xlYW51cCwgRmNhbGxf cHJvY2Vzcyk6IFVzZSB0aGVtLgorCShjYWxsX3Byb2Nlc3Nfa2lsbCk6IFJlY29yZCBraWxs ZWQgcHJvY2Vzc2VzIGFzIGRlbGV0ZWQsIHNvIHRoYXQKKwl6b21iaWVzIGRvIG5vdCBjbHV0 dGVyIHVwIHRoZSBzeXN0ZW0uICBEbyB0aGlzIGluc2lkZSBhIGNyaXRpY2FsCisJc2VjdGlv biwgdG8gYXZvaWQgYSByYWNlIHRoYXQgd291bGQgYWxsb3cgdGhlIGNsdXR0ZXIuICBEbyBu b3QKKwlhc3N1bWUgdGhhdCBzZW5kaW5nIFNJR0tJTEwgdG8gYSBwcm9jZXNzIG1ha2VzIGl0 IHJlYXBhYmxlLgorCShjYWxsX3Byb2Nlc3NfY2xlYW51cCk6IEZpeCBjb2RlIHNvIHRoYXQg dGhlIHNlY29uZCBDLWcgd29ya3MgYWdhaW4KKwlvbiBjb21tb24gcGxhdGZvcm1zIHN1Y2gg YXMgR05VL0xpbnV4LgorCShGY2FsbF9wcm9jZXNzKTogQ3JlYXRlIHRoZSBjaGlsZCBwcm9j ZXNzIGluIGEgY3JpdGljYWwgc2VjdGlvbiwKKwl0byBmaXggYSByYWNlIGNvbmRpdGlvbi4g IElmIGNyZWF0aW5nIGFuIGFzeW5jaHJvbm91cyBwcm9jZXNzLAorCXJlY29yZCBpdCBhcyBk ZWxldGVkIHNvIHRoYXQgem9tYmllcyBkbyBub3QgY2x1dHRlciB1cCB0aGUgc3lzdGVtLgor CURvIG5vdCBzdG9yZSBwcm9jZXNzIHN0YXRlIGluIHN0YXRpYyB2YXJpYWJsZXMsIGFzIHRo YXQncyBsZXNzIHNhZmUuCisJKiBjYWxscHJvYy5jIChjYWxsX3Byb2Nlc3NfY2xlYW51cCk6 CisJKiB3MzJwcm9jLmMgKHdhaXRwaWQpOiBTaW1wbGlmeSBub3cgdGhhdCBzeW5jaF9wcm9j ZXNzX2FsaXZlIGlzIGdvbmUuCisJKiBwcm9jZXNzLmMgKHJlY29yZF9kZWxldGVkX3BpZCk6 IE5ldyBmdW5jdGlvbiwgY29udGFpbmluZworCWNvZGUgcmVmYWN0b3JlZCBvdXQgb2YgRmRl bGV0ZV9wcm9jZXNzLgorCShGZGVsZXRlX3Byb2Nlc3MpOiBVc2UgaXQuCisJKHByb2Nlc3Nf c3RhdHVzX3JldHJpZXZlZCk6IENoYW5nZSBhcmdzIHRvIGxvb2sgbW9yZSBsaWtlIHRob3Nl IG9mCisJd2FpdHBpZDsgdGhpcyBpcyBjbGVhcmVyLiAgUmV0dXJuIHRydWUgaWYgdGhlIHBy b2Nlc3MgaGFzIGNoYW5nZWQsCisJZmFsc2Ugb3RoZXJ3aXNlLiAgQWxsIHVzZXMgY2hhbmdl ZC4gIERlZmluZSBvbmx5IGlmIFNJR0NITEQuCisJKHJlY29yZF9jaGlsZF9zdGF0dXNfY2hh bmdlKTogUmVtb3ZlLCBmb2xkaW5nIGl0cyBjb250ZW50cyBpbnRvIC4uLgorCShoYW5kbGVf Y2hpbGRfc2lnbmFsKTogLi4uIHRoaXMgc2lnbmFsIGhhbmRsZXIuICBOb3csIHRoaXMKKwlm dW5jdGlvbiBpcyBwdXJlbHkgYSBoYW5kbGVyIGZvciBTSUdDSExELCBhbmQgaXMgbm90IGNh bGxlZCBhZnRlcgorCWEgc3luY2hyb25vdXMgd2FpdHBpZCByZXR1cm5zOyB0aGUgc3luY2hy b25vdXMgY29kZSBpcyBtb3ZlZCB0bworCXdhaXRfZm9yX3Rlcm1pbmF0aW9uLiAgVGhlcmUg aXMgbm8gbmVlZCB0byB3b3JyeSBhYm91dCByZWFwaW5nCisJbW9yZSB0aGFuIG9uZSBjaGls ZCBub3cuCisJKiBzeXNkZXAuYyAod2FpdF9mb3JfdGVybWluYXRpb24pOiBOb3cgdGFrZXMg aW50ICogc3RhdHVzIGFuZCBib29sCisJaW50ZXJydXB0aWJsZSBhcmd1bWVudHMsIHRvby4g IERvIG5vdCByZWNvcmQgY2hpbGQgc3RhdHVzIGNoYW5nZTsKKwl0aGF0J3Mgbm93IHRoZSBj YWxsZXIncyByZXNwb25zaWJpbGl0eS4gIEFsbCBjYWxsZXJzIGNoYW5nZWQuCisJKHdhaXRf Zm9yX3Rlcm1pbmF0aW9uXzEsIGludGVycnVwdGlibGVfd2FpdF9mb3JfdGVybWluYXRpb24p OgorCVJlbW92ZS4gIEFsbCBjYWxsZXJzIGNoYW5nZWQgdG8gdXNlIHdhaXRfZm9yX3Rlcm1p bmF0aW9uLgorCSogc3lzd2FpdC5oOiBJbmNsdWRlIDxzdGRib29sLmg+LCBmb3IgYm9vbC4K KwkocmVjb3JkX2NoaWxkX3N0YXR1c19jaGFuZ2UsIGludGVycnVwdGlibGVfd2FpdF9mb3Jf dGVybWluYXRpb24pOgorCVJlbW92ZSBkZWNscy4KKwkocmVjb3JkX2RlbGV0ZWRfcGlkKTog TmV3IGRlY2wuCisJKHdhaXRfZm9yX3Rlcm1pbmF0aW9uKTogQWRqdXN0IHRvIEFQSSBjaGFu Z2VzIG5vdGVkIGFib3ZlLgorCiAyMDEyLTExLTI1ICBQYXVsIEVnZ2VydCAgPGVnZ2VydEBj cy51Y2xhLmVkdT4KIAogCSogc3lzZGVwLmMgKHN5c19zdWJzaGVsbCk6IERvbid0IGFzc3Vt ZSBwaWRfdCBmaXRzIGluIGludC4KCj09PSBtb2RpZmllZCBmaWxlICdzcmMvY2FsbHByb2Mu YycKLS0tIHNyYy9jYWxscHJvYy5jCTIwMTItMTEtMTcgMjI6MTI6NDcgKzAwMDAKKysrIHNy Yy9jYWxscHJvYy5jCTIwMTItMTEtMjYgMjI6MTU6NDIgKzAwMDAKQEAgLTY3LDIxICs2Nyw1 NyBAQAogLyogUGF0dGVybiB1c2VkIGJ5IGNhbGwtcHJvY2Vzcy1yZWdpb24gdG8gbWFrZSB0 ZW1wIGZpbGVzLiAgKi8KIHN0YXRpYyBMaXNwX09iamVjdCBWdGVtcF9maWxlX25hbWVfcGF0 dGVybjsKIAotLyogVHJ1ZSBpZiB3ZSBhcmUgYWJvdXQgdG8gZm9yayBvZmYgYSBzeW5jaHJv bm91cyBwcm9jZXNzIG9yIGlmIHdlCi0gICBhcmUgd2FpdGluZyBmb3IgaXQuICAqLwotYm9v bCBzeW5jaF9wcm9jZXNzX2FsaXZlOwotCi0vKiBOb256ZXJvID0+IHRoaXMgaXMgYSBzdHJp bmcgZXhwbGFpbmluZyBkZWF0aCBvZiBzeW5jaHJvbm91cyBzdWJwcm9jZXNzLiAgKi8KLWNv bnN0IGNoYXIgKnN5bmNoX3Byb2Nlc3NfZGVhdGg7Ci0KLS8qIE5vbnplcm8gPT4gdGhpcyBp cyB0aGUgc2lnbmFsIG51bWJlciB0aGF0IHRlcm1pbmF0ZWQgdGhlIHN1YnByb2Nlc3MuICAq LwotaW50IHN5bmNoX3Byb2Nlc3NfdGVybXNpZzsKLQotLyogSWYgc3luY2hfcHJvY2Vzc19k ZWF0aCBpcyB6ZXJvLAotICAgdGhpcyBpcyBleGl0IGNvZGUgb2Ygc3luY2hyb25vdXMgc3Vi cHJvY2Vzcy4gICovCi1pbnQgc3luY2hfcHJvY2Vzc19yZXRjb2RlOwotCiAMCisvKiBSZXR1 cm4gdHJ1ZSBpZiBDSElMRCBpcyByZWFwYWJsZS4gIENISUxEIG11c3QgYmUgdGhlIHByb2Nl c3MgSUQgb2YKKyAgIGEgY2hpbGQgcHJvY2Vzcy4gIEFzIGEgc2lkZSBlZmZlY3QgdGhpcyBm dW5jdGlvbiBtYXkgcmVhcCBDSElMRCwKKyAgIGRpc2NhcmRpbmcgaXRzIHN0YXR1cywgYW5k IHRoZXJlZm9yZSByZXBvcnQgdGhhdCBDSElMRCBpcyBub3QKKyAgIHJlYXBhYmxlLgorCisg ICBUaGlzIGZ1bmN0aW9uIGlzIGludGVuZGVkIGZvciB1c2UgYWZ0ZXIgdGhlIGNhbGxlciB3 YXMgaW50ZXJydXB0ZWQKKyAgIHdoaWxlIHRyeWluZyB0byByZWFwIENISUxELCBhbmQgd2hl cmUgdGhlIGNhbGxlciBsYXRlciB0ZXN0cworICAgd2hldGhlciBDSElMRCB3YXMgaW4gZmFj dCByZWFwZWQuICBUaGUgY2FsbGVyIHNob3VsZCBub3QgY3JlYXRlCisgICBhbm90aGVyIGNo aWxkIHByb2Nlc3MgKHZpYSB2Zm9yaywgc2F5KSBiZXR3ZWVuIHRoZSBlYXJsaWVyIGF0dGVt cHQKKyAgIHRvIHJlYXAgQ0hJTEQgYW5kIG5vdywgYXMgdGhhdCB3b3VsZCBjYXVzZSBhIHJh Y2UgaWYgdGhlIG5ld2x5CisgICBjcmVhdGVkIGNoaWxkIHByb2Nlc3MgaGFwcGVuZWQgdG8g aGF2ZSBDSElMRCBhcyBpdHMgcHJvY2Vzcy1JRC4gICovCisKK3N0YXRpYyBib29sCityZWFw YWJsZV9jaGlsZCAocGlkX3QgY2hpbGQpCit7CisgIC8qIERvIG5vdCB1c2Uga2lsbCAoQ0hJ TEQsIC4uLikgdG8gdGVzdCB3aGV0aGVyIENISUxEIGlzIHJlYXBhYmxlLAorICAgICBhcyB0 aGF0IG1pZ2h0IGtpbGwgYW4gaW5ub2NlbnQgdmljdGltIGlmIENISUxEIGhhcyBhbHJlYWR5 IGJlZW4gcmVhcGVkCisgICAgIGFuZCBDSElMRCdzIFBJRCBoYXMgYmVlbiByZXVzZWQuICAq LworICBpbnQgc3RhdHVzOworICBwaWRfdCBwaWQ7CisgIGRvCisgICAgcGlkID0gd2FpdHBp ZCAoY2hpbGQsICZzdGF0dXMsIFdOT0hBTkcpOworICB3aGlsZSAocGlkIDwgMCAmJiBlcnJu byA9PSBFSU5UUik7CisKKyAgcmV0dXJuICFwaWQ7Cit9CisKKy8qIEJsb2NrIFNJR0NITEQu ICAqLworCitzdGF0aWMgdm9pZAorYmxvY2tfY2hpbGRfc2lnbmFsICh2b2lkKQoreworI2lm ZGVmIFNJR0NITEQKKyAgc2lnc2V0X3QgYmxvY2tlZDsKKyAgc2lnZW1wdHlzZXQgKCZibG9j a2VkKTsKKyAgc2lnYWRkc2V0ICgmYmxvY2tlZCwgU0lHQ0hMRCk7CisgIHB0aHJlYWRfc2ln bWFzayAoU0lHX0JMT0NLLCAmYmxvY2tlZCwgMCk7CisjZW5kaWYKK30KKworLyogVW5ibG9j ayBTSUdDSExELiAgKi8KKworc3RhdGljIHZvaWQKK3VuYmxvY2tfY2hpbGRfc2lnbmFsICh2 b2lkKQoreworI2lmZGVmIFNJR0NITEQKKyAgcHRocmVhZF9zaWdtYXNrIChTSUdfU0VUTUFT SywgJmVtcHR5X21hc2ssIDApOworI2VuZGlmCit9CisKIC8qIENsZWFuIHVwIHdoZW4gZXhp dGluZyBGY2FsbF9wcm9jZXNzLgogICAgT24gTVNET1MsIGRlbGV0ZSB0aGUgdGVtcG9yYXJ5 IGZpbGUgb24gYW55IGtpbmQgb2YgdGVybWluYXRpb24uCiAgICBPbiBVbml4LCBraWxsIHRo ZSBwcm9jZXNzIGFuZCBhbnkgY2hpbGRyZW4gb24gdGVybWluYXRpb24gYnkgc2lnbmFsLiAg Ki8KQEAgLTk3LDggKzEzMywxOCBAQAogICBDT05TX1RPX0lOVEVHRVIgKEZjYXIgKGZkcGlk KSwgaW50LCBmZCk7CiAgIENPTlNfVE9fSU5URUdFUiAoRmNkciAoZmRwaWQpLCBwaWRfdCwg cGlkKTsKICAgZW1hY3NfY2xvc2UgKGZkKTsKLSAgRU1BQ1NfS0lMTFBHIChwaWQsIFNJR0tJ TEwpOwotICBzeW5jaF9wcm9jZXNzX2FsaXZlID0gMDsKKworICBpZiAocmVhcGFibGVfY2hp bGQgKHBpZCkgJiYgRU1BQ1NfS0lMTFBHIChwaWQsIFNJR0tJTEwpID09IDApCisgICAgewor ICAgICAgLyogUmVjb3JkIFBJRCBhcyBhIGRlbGV0ZWQgcHJvY2Vzcy4gIERvIHRoaXMgaW4g YSBjcml0aWNhbAorCSBzZWN0aW9uLCBhcyByZWNvcmRfZGVsZXRlZF9waWQgaXMgbm90IGFz eW5jLXNpZ25hbC1zYWZlLgorCSBQSUQgd2lsbCBiZSByZWFwZWQgb24gcmVjZWlwdCBvZiB0 aGUgZmlyc3QgU0lHQ0hMRCBhZnRlciB0aGUKKwkgY3JpdGljYWwgc2VjdGlvbi4gICovCisg ICAgICBibG9ja19jaGlsZF9zaWduYWwgKCk7CisgICAgICByZWNvcmRfZGVsZXRlZF9waWQg KHBpZCk7CisgICAgICB1bmJsb2NrX2NoaWxkX3NpZ25hbCAoKTsKKyAgICB9CisKICAgcmV0 dXJuIFFuaWw7CiB9CiAKQEAgLTEwNyw0NiArMTUzLDQzIEBACiB7CiAgIExpc3BfT2JqZWN0 IGZkcGlkID0gRmNkciAoYXJnKTsKICAgaW50IGZkOwotI2lmIGRlZmluZWQgKE1TRE9TKQot ICBMaXNwX09iamVjdCBmaWxlOwotI2Vsc2UKLSAgcGlkX3QgcGlkOwotI2VuZGlmCiAKICAg RnNldF9idWZmZXIgKEZjYXIgKGFyZykpOwogICBDT05TX1RPX0lOVEVHRVIgKEZjYXIgKGZk cGlkKSwgaW50LCBmZCk7CiAKICNpZiBkZWZpbmVkIChNU0RPUykKLSAgLyogZm9yIE1TRE9T IGZkcGlkIGlzIHJlYWxseSAoZmQgLiB0ZW1wZmlsZSkgICovCi0gIGZpbGUgPSBGY2RyIChm ZHBpZCk7Ci0gIC8qIEZEIGlzIC0xIGFuZCBGSUxFIGlzICIiIHdoZW4gd2UgZGlkbid0IGFj dHVhbGx5IGNyZWF0ZSBhCi0gICAgIHRlbXBvcmFyeSBmaWxlIGluIGNhbGwtcHJvY2Vzcy4g ICovCi0gIGlmIChmZCA+PSAwKQotICAgIGVtYWNzX2Nsb3NlIChmZCk7Ci0gIGlmICghKHN0 cmNtcCAoU0RBVEEgKGZpbGUpLCBOVUxMX0RFVklDRSkgPT0gMCB8fCBTUkVGIChmaWxlLCAw KSA9PSAnXDAnKSkKLSAgICB1bmxpbmsgKFNEQVRBIChmaWxlKSk7CisgIHsKKyAgICAvKiBm b3IgTVNET1MgZmRwaWQgaXMgcmVhbGx5IChmZCAuIHRlbXBmaWxlKSAgKi8KKyAgICBMaXNw X09iamVjdCBmaWxlID0gRmNkciAoZmRwaWQpOworICAgIC8qIEZEIGlzIC0xIGFuZCBGSUxF IGlzICIiIHdoZW4gd2UgZGlkbid0IGFjdHVhbGx5IGNyZWF0ZSBhCisgICAgICAgdGVtcG9y YXJ5IGZpbGUgaW4gY2FsbC1wcm9jZXNzLiAgKi8KKyAgICBpZiAoZmQgPj0gMCkKKyAgICAg IGVtYWNzX2Nsb3NlIChmZCk7CisgICAgaWYgKCEoc3RyY21wIChTREFUQSAoZmlsZSksIE5V TExfREVWSUNFKSA9PSAwIHx8IFNSRUYgKGZpbGUsIDApID09ICdcMCcpKQorICAgICAgdW5s aW5rIChTREFUQSAoZmlsZSkpOworICB9CiAjZWxzZSAvKiBub3QgTVNET1MgKi8KLSAgQ09O U19UT19JTlRFR0VSIChGY2RyIChmZHBpZCksIHBpZF90LCBwaWQpOwotCi0gIGlmIChjYWxs X3Byb2Nlc3NfZXhpdGVkKQotICAgIHsKLSAgICAgIGVtYWNzX2Nsb3NlIChmZCk7Ci0gICAg ICByZXR1cm4gUW5pbDsKLSAgICB9Ci0KLSAgaWYgKEVNQUNTX0tJTExQRyAocGlkLCBTSUdJ TlQpID09IDApCi0gICAgewotICAgICAgcHRyZGlmZl90IGNvdW50ID0gU1BFQ1BETF9JTkRF WCAoKTsKLSAgICAgIHJlY29yZF91bndpbmRfcHJvdGVjdCAoY2FsbF9wcm9jZXNzX2tpbGws IGZkcGlkKTsKLSAgICAgIG1lc3NhZ2UxICgiV2FpdGluZyBmb3IgcHJvY2VzcyB0byBkaWUu Li4odHlwZSBDLWcgYWdhaW4gdG8ga2lsbCBpdCBpbnN0YW50bHkpIik7Ci0gICAgICBpbW1l ZGlhdGVfcXVpdCA9IDE7Ci0gICAgICBRVUlUOwotICAgICAgd2FpdF9mb3JfdGVybWluYXRp b24gKHBpZCk7Ci0gICAgICBpbW1lZGlhdGVfcXVpdCA9IDA7Ci0gICAgICBzcGVjcGRsX3B0 ciA9IHNwZWNwZGwgKyBjb3VudDsgLyogRGlzY2FyZCB0aGUgdW53aW5kIHByb3RlY3QuICAq LwotICAgICAgbWVzc2FnZTEgKCJXYWl0aW5nIGZvciBwcm9jZXNzIHRvIGRpZS4uLmRvbmUi KTsKLSAgICB9Ci0gIHN5bmNoX3Byb2Nlc3NfYWxpdmUgPSAwOworCisgIC8qIElmIHRoZSBw cm9jZXNzIHN0aWxsIGV4aXN0cywga2lsbCBpdHMgcHJvY2VzcyBncm91cC4gICovCisgIGlm ICghY2FsbF9wcm9jZXNzX2V4aXRlZCkKKyAgICB7CisgICAgICBwaWRfdCBwaWQ7CisgICAg ICBDT05TX1RPX0lOVEVHRVIgKEZjZHIgKGZkcGlkKSwgcGlkX3QsIHBpZCk7CisKKyAgICAg IGlmIChyZWFwYWJsZV9jaGlsZCAocGlkKSAmJiBFTUFDU19LSUxMUEcgKHBpZCwgU0lHSU5U KSA9PSAwKQorCXsKKwkgIHB0cmRpZmZfdCBjb3VudCA9IFNQRUNQRExfSU5ERVggKCk7CisJ ICByZWNvcmRfdW53aW5kX3Byb3RlY3QgKGNhbGxfcHJvY2Vzc19raWxsLCBmZHBpZCk7CisJ ICBtZXNzYWdlMSAoIldhaXRpbmcgZm9yIHByb2Nlc3MgdG8gZGllLi4uIgorCQkgICAgIih0 eXBlIEMtZyBhZ2FpbiB0byBraWxsIGl0IGluc3RhbnRseSkiKTsKKwkgIGltbWVkaWF0ZV9x dWl0ID0gMTsKKwkgIFFVSVQ7CisJICB3YWl0X2Zvcl90ZXJtaW5hdGlvbiAocGlkLCAwLCAx KTsKKwkgIGltbWVkaWF0ZV9xdWl0ID0gMDsKKwkgIHNwZWNwZGxfcHRyID0gc3BlY3BkbCAr IGNvdW50OyAvKiBEaXNjYXJkIHRoZSB1bndpbmQgcHJvdGVjdC4gICovCisJICBtZXNzYWdl MSAoIldhaXRpbmcgZm9yIHByb2Nlc3MgdG8gZGllLi4uZG9uZSIpOworCX0KKyAgICB9CiAg IGVtYWNzX2Nsb3NlIChmZCk7CiAjZW5kaWYgLyogbm90IE1TRE9TICovCiAgIHJldHVybiBR bmlsOwpAQCAtMTg5LDYgKzIzMiw3IEBACiAjZGVmaW5lIENBTExQUk9DX0JVRkZFUl9TSVpF X01BWCAoNCAqIENBTExQUk9DX0JVRkZFUl9TSVpFX01JTikKICAgY2hhciBidWZbQ0FMTFBS T0NfQlVGRkVSX1NJWkVfTUFYXTsKICAgaW50IGJ1ZnNpemUgPSBDQUxMUFJPQ19CVUZGRVJf U0laRV9NSU47CisgIGludCBzdGF0dXM7CiAgIHB0cmRpZmZfdCBjb3VudCA9IFNQRUNQRExf SU5ERVggKCk7CiAgIFVTRV9TQUZFX0FMTE9DQTsKIApAQCAtNDk0LDE2ICs1MzgsNiBAQAog ICAgIGlmIChmZF9vdXRwdXQgPj0gMCkKICAgICAgIGZkMSA9IGZkX291dHB1dDsKIAotICAg IC8qIFJlY29yZCB0aGF0IHdlJ3JlIGFib3V0IHRvIGNyZWF0ZSBhIHN5bmNocm9ub3VzIHBy b2Nlc3MuICAqLwotICAgIHN5bmNoX3Byb2Nlc3NfYWxpdmUgPSAxOwotCi0gICAgLyogVGhl c2UgdmFycyByZWNvcmQgaW5mb3JtYXRpb24gZnJvbSBwcm9jZXNzIHRlcm1pbmF0aW9uLgot ICAgICAgIENsZWFyIHRoZW0gbm93IGJlZm9yZSBwcm9jZXNzIGNhbiBwb3NzaWJseSB0ZXJt aW5hdGUsCi0gICAgICAgdG8gYXZvaWQgdGltaW5nIGVycm9yIGlmIHByb2Nlc3MgdGVybWlu YXRlcyBzb29uLiAgKi8KLSAgICBzeW5jaF9wcm9jZXNzX2RlYXRoID0gMDsKLSAgICBzeW5j aF9wcm9jZXNzX3JldGNvZGUgPSAwOwotICAgIHN5bmNoX3Byb2Nlc3NfdGVybXNpZyA9IDA7 Ci0KICAgICBpZiAoTklMUCAoZXJyb3JfZmlsZSkpCiAgICAgICBmZF9lcnJvciA9IGVtYWNz X29wZW4gKE5VTExfREVWSUNFLCBPX1dST05MWSwgMCk7CiAgICAgZWxzZSBpZiAoU1RSSU5H UCAoZXJyb3JfZmlsZSkpCkBAIC01MzYsMjAgKzU3MCwxMCBAQAogCiAjaWZkZWYgTVNET1Mg LyogTVcsIEp1bHkgMTk5MyAqLwogICAgIC8qIE5vdGUgdGhhdCBvbiBNU0RPUyBgY2hpbGRf c2V0dXAnIGFjdHVhbGx5IHJldHVybnMgdGhlIGNoaWxkIHByb2Nlc3MKLSAgICAgICBleGl0 IHN0YXR1cywgbm90IGl0cyBQSUQsIHNvIHdlIGFzc2lnbiBpdCB0byBgc3luY2hfcHJvY2Vz c19yZXRjb2RlJwotICAgICAgIGJlbG93LiAgKi8KKyAgICAgICBleGl0IHN0YXR1cywgbm90 IGl0cyBQSUQsIHNvIGFzc2lnbiBpdCB0byBzdGF0dXMgYmVsb3cuICAqLwogICAgIHBpZCA9 IGNoaWxkX3NldHVwIChmaWxlZmQsIG91dGZpbGVmZCwgZmRfZXJyb3IsIChjaGFyICoqKSBu ZXdfYXJndiwKIAkJICAgICAgIDAsIGN1cnJlbnRfZGlyKTsKLQotICAgIC8qIFJlY29yZCB0 aGF0IHRoZSBzeW5jaHJvbm91cyBwcm9jZXNzIGV4aXRlZCBhbmQgbm90ZSBpdHMKLSAgICAg ICB0ZXJtaW5hdGlvbiBzdGF0dXMuICAqLwotICAgIHN5bmNoX3Byb2Nlc3NfYWxpdmUgPSAw OwotICAgIHN5bmNoX3Byb2Nlc3NfcmV0Y29kZSA9IHBpZDsKLSAgICBpZiAoc3luY2hfcHJv Y2Vzc19yZXRjb2RlIDwgMCkgIC8qIG1lYW5zIGl0IGNvdWxkbid0IGJlIGV4ZWMnZWQgKi8K LSAgICAgIHsKLQlzeW5jaHJvbml6ZV9zeXN0ZW1fbWVzc2FnZXNfbG9jYWxlICgpOwotCXN5 bmNoX3Byb2Nlc3NfZGVhdGggPSBzdHJlcnJvciAoZXJybm8pOwotICAgICAgfQorICAgIHN0 YXR1cyA9IHBpZDsKIAogICAgIGVtYWNzX2Nsb3NlIChvdXRmaWxlZmQpOwogICAgIGlmIChm ZF9lcnJvciAhPSBvdXRmaWxlZmQpCkBAIC01NzcsNiArNjAxLDcgQEAKICNlbHNlICAvKiBu b3QgV0lORE9XU05UICovCiAKICAgICBibG9ja19pbnB1dCAoKTsKKyAgICBibG9ja19jaGls ZF9zaWduYWwgKCk7CiAKICAgICAvKiB2Zm9yaywgYW5kIHByZXZlbnQgbG9jYWwgdmFycyBm cm9tIGJlaW5nIGNsb2JiZXJlZCBieSB0aGUgdmZvcmsuICAqLwogICAgIHsKQEAgLTYwOSw2 ICs2MzQsOCBAQAogCiAgICAgaWYgKHBpZCA9PSAwKQogICAgICAgeworCXVuYmxvY2tfY2hp bGRfc2lnbmFsICgpOworCiAJaWYgKGZkWzBdID49IDApCiAJICBlbWFjc19jbG9zZSAoZmRb MF0pOwogCkBAIC02MjEsNiArNjQ4LDI2IEBACiAJCSAgICAgMCwgY3VycmVudF9kaXIpOwog ICAgICAgfQogCisgICAgaWYgKDAgPCBwaWQpCisgICAgICB7CisJaWYgKElOVEVHRVJQIChi dWZmZXIpKQorCSAgcmVjb3JkX2RlbGV0ZWRfcGlkIChwaWQpOworCWVsc2UKKwkgIHsKKyNp ZmRlZiBNU0RPUworCSAgICAvKiBNU0RPUyBuZWVkcyBkaWZmZXJlbnQgY2xlYW51cCBpbmZv cm1hdGlvbi4gICovCisJICAgIGNsZWFudXBfaW5mb190YWlsID0gYnVpbGRfc3RyaW5nICh0 ZW1wZmlsZSA/IHRlbXBmaWxlIDogIiIpOworI2Vsc2UKKwkgICAgY2xlYW51cF9pbmZvX3Rh aWwgPSBJTlRFR0VSX1RPX0NPTlMgKHBpZCk7CisjZW5kaWYKKwkgICAgcmVjb3JkX3Vud2lu ZF9wcm90ZWN0IChjYWxsX3Byb2Nlc3NfY2xlYW51cCwKKwkJCQkgICBGY29ucyAoRmN1cnJl bnRfYnVmZmVyICgpLAorCQkJCQkgIEZjb25zIChJTlRFR0VSX1RPX0NPTlMgKGZkWzBdKSwK KwkJCQkJCSBjbGVhbnVwX2luZm9fdGFpbCkpKTsKKwkgIH0KKyAgICAgIH0KKworICAgIHVu YmxvY2tfY2hpbGRfc2lnbmFsICgpOwogICAgIHVuYmxvY2tfaW5wdXQgKCk7CiAKICNlbmRp ZiAvKiBub3QgV0lORE9XU05UICovCkBAIC02NTgsMTcgKzcwNSw2IEBACiAgIC8qIEVuYWJs ZSBzZW5kaW5nIHNpZ25hbCBpZiB1c2VyIHF1aXRzIGJlbG93LiAgKi8KICAgY2FsbF9wcm9j ZXNzX2V4aXRlZCA9IDA7CiAKLSNpZiBkZWZpbmVkIChNU0RPUykKLSAgLyogTVNET1MgbmVl ZHMgZGlmZmVyZW50IGNsZWFudXAgaW5mb3JtYXRpb24uICAqLwotICBjbGVhbnVwX2luZm9f dGFpbCA9IGJ1aWxkX3N0cmluZyAodGVtcGZpbGUgPyB0ZW1wZmlsZSA6ICIiKTsKLSNlbHNl Ci0gIGNsZWFudXBfaW5mb190YWlsID0gSU5URUdFUl9UT19DT05TIChwaWQpOwotI2VuZGlm IC8qIG5vdCBNU0RPUyAqLwotICByZWNvcmRfdW53aW5kX3Byb3RlY3QgKGNhbGxfcHJvY2Vz c19jbGVhbnVwLAotCQkJIEZjb25zIChGY3VycmVudF9idWZmZXIgKCksCi0JCQkJRmNvbnMg KElOVEVHRVJfVE9fQ09OUyAoZmRbMF0pLAotCQkJCSAgICAgICBjbGVhbnVwX2luZm9fdGFp bCkpKTsKLQogICBpZiAoQlVGRkVSUCAoYnVmZmVyKSkKICAgICBGc2V0X2J1ZmZlciAoYnVm ZmVyKTsKIApAQCAtODUwLDEwICs4ODYsNyBAQAogCiAjaWZuZGVmIE1TRE9TCiAgIC8qIFdh aXQgZm9yIGl0IHRvIHRlcm1pbmF0ZSwgdW5sZXNzIGl0IGFscmVhZHkgaGFzLiAgKi8KLSAg aWYgKG91dHB1dF90b19idWZmZXIpCi0gICAgd2FpdF9mb3JfdGVybWluYXRpb24gKHBpZCk7 Ci0gIGVsc2UKLSAgICBpbnRlcnJ1cHRpYmxlX3dhaXRfZm9yX3Rlcm1pbmF0aW9uIChwaWQp OworICB3YWl0X2Zvcl90ZXJtaW5hdGlvbiAocGlkLCAmc3RhdHVzLCAhb3V0cHV0X3RvX2J1 ZmZlcik7CiAjZW5kaWYKIAogICBpbW1lZGlhdGVfcXVpdCA9IDA7CkBAIC04NjUsMjMgKzg5 OCwyMiBAQAogICBTQUZFX0ZSRUUgKCk7CiAgIHVuYmluZF90byAoY291bnQsIFFuaWwpOwog Ci0gIGlmIChzeW5jaF9wcm9jZXNzX3Rlcm1zaWcpCisgIGlmIChXSUZTSUdOQUxFRCAoc3Rh dHVzKSkKICAgICB7CiAgICAgICBjb25zdCBjaGFyICpzaWduYW1lOwogCiAgICAgICBzeW5j aHJvbml6ZV9zeXN0ZW1fbWVzc2FnZXNfbG9jYWxlICgpOwotICAgICAgc2lnbmFtZSA9IHN0 cnNpZ25hbCAoc3luY2hfcHJvY2Vzc190ZXJtc2lnKTsKKyAgICAgIHNpZ25hbWUgPSBzdHJz aWduYWwgKFdURVJNU0lHIChzdGF0dXMpKTsKIAogICAgICAgaWYgKHNpZ25hbWUgPT0gMCkK IAlzaWduYW1lID0gInVua25vd24iOwogCi0gICAgICBzeW5jaF9wcm9jZXNzX2RlYXRoID0g c2lnbmFtZTsKKyAgICAgIHJldHVybiBjb2RlX2NvbnZlcnRfc3RyaW5nX25vcmVjb3JkIChi dWlsZF9zdHJpbmcgKHNpZ25hbWUpLAorCQkJCQkgICBWbG9jYWxlX2NvZGluZ19zeXN0ZW0s IDApOwogICAgIH0KIAotICBpZiAoc3luY2hfcHJvY2Vzc19kZWF0aCkKLSAgICByZXR1cm4g Y29kZV9jb252ZXJ0X3N0cmluZ19ub3JlY29yZCAoYnVpbGRfc3RyaW5nIChzeW5jaF9wcm9j ZXNzX2RlYXRoKSwKLQkJCQkJIFZsb2NhbGVfY29kaW5nX3N5c3RlbSwgMCk7Ci0gIHJldHVy biBtYWtlX251bWJlciAoc3luY2hfcHJvY2Vzc19yZXRjb2RlKTsKKyAgZWFzc2VydCAoV0lG RVhJVEVEIChzdGF0dXMpKTsKKyAgcmV0dXJuIG1ha2VfbnVtYmVyIChXRVhJVFNUQVRVUyAo c3RhdHVzKSk7CiB9CiAMCiBzdGF0aWMgTGlzcF9PYmplY3QKCj09PSBtb2RpZmllZCBmaWxl ICdzcmMvcHJvY2Vzcy5jJwotLS0gc3JjL3Byb2Nlc3MuYwkyMDEyLTExLTI0IDAxOjU3OjA5 ICswMDAwCisrKyBzcmMvcHJvY2Vzcy5jCTIwMTItMTEtMjYgMjI6MDY6MjQgKzAwMDAKQEAg LTc3NywxMCArNzc3LDIzIEBACiAvKiBGZGVsZXRlX3Byb2Nlc3MgcHJvbWlzZXMgdG8gaW1t ZWRpYXRlbHkgZm9yZ2V0IGFib3V0IHRoZSBwcm9jZXNzLCBidXQgaW4KICAgIHJlYWxpdHks IEVtYWNzIG5lZWRzIHRvIHJlbWVtYmVyIHRob3NlIHByb2Nlc3NlcyB1bnRpbCB0aGV5IGhh dmUgYmVlbgogICAgdHJlYXRlZCBieSB0aGUgU0lHQ0hMRCBoYW5kbGVyIGFuZCB3YWl0cGlk IGhhcyBiZWVuIGludm9rZWQgb24gdGhlbTsKLSAgIG90aGVyd2lzZSB0aGV5IG1pZ2h0IGZp bGwgdXAgdGhlIGtlcm5lbCdzIHByb2Nlc3MgdGFibGUuICAqLworICAgb3RoZXJ3aXNlIHRo ZXkgbWlnaHQgZmlsbCB1cCB0aGUga2VybmVsJ3MgcHJvY2VzcyB0YWJsZS4KKworICAgU29t ZSBwcm9jZXNzZXMgY3JlYXRlZCBieSBjYWxsLXByb2Nlc3MgYXJlIGFsc28gcHV0IG9udG8g dGhpcyBsaXN0LiAgKi8KIHN0YXRpYyBMaXNwX09iamVjdCBkZWxldGVkX3BpZF9saXN0Owog I2VuZGlmCiAKK3ZvaWQKK3JlY29yZF9kZWxldGVkX3BpZCAocGlkX3QgcGlkKQoreworI2lm ZGVmIFNJR0NITEQKKyAgZGVsZXRlZF9waWRfbGlzdCA9IEZjb25zIChtYWtlX2ZpeG51bV9v cl9mbG9hdCAocGlkKSwKKwkJCSAgICAvKiBHQyB0cmVhdGVkIGVsZW1lbnRzIHNldCB0byBu aWwuICAqLworCQkJICAgIEZkZWxxIChRbmlsLCBkZWxldGVkX3BpZF9saXN0KSk7CisKKyNl bmRpZgorfQorCiBERUZVTiAoImRlbGV0ZS1wcm9jZXNzIiwgRmRlbGV0ZV9wcm9jZXNzLCBT ZGVsZXRlX3Byb2Nlc3MsIDEsIDEsIDAsCiAgICAgICAgZG9jOiAvKiBEZWxldGUgUFJPQ0VT Uzoga2lsbCBpdCBhbmQgZm9yZ2V0IGFib3V0IGl0IGltbWVkaWF0ZWx5LgogUFJPQ0VTUyBt YXkgYmUgYSBwcm9jZXNzLCBhIGJ1ZmZlciwgdGhlIG5hbWUgb2YgYSBwcm9jZXNzIG9yIGJ1 ZmZlciwgb3IKQEAgLTgwNyw5ICs4MjAsNyBAQAogICAgICAgcGlkX3QgcGlkID0gcC0+cGlk OwogCiAgICAgICAvKiBObyBwcm9ibGVtIHN0b3JpbmcgdGhlIHBpZCBoZXJlLCBhcyBpdCBp cyBzdGlsbCBpbiBWcHJvY2Vzc19hbGlzdC4gICovCi0gICAgICBkZWxldGVkX3BpZF9saXN0 ID0gRmNvbnMgKG1ha2VfZml4bnVtX29yX2Zsb2F0IChwaWQpLAotCQkJCS8qIEdDIHRyZWF0 ZWQgZWxlbWVudHMgc2V0IHRvIG5pbC4gICovCi0JCQkJRmRlbHEgKFFuaWwsIGRlbGV0ZWRf cGlkX2xpc3QpKTsKKyAgICAgIHJlY29yZF9kZWxldGVkX3BpZCAocGlkKTsKICAgICAgIC8q IElmIHRoZSBwcm9jZXNzIGhhcyBhbHJlYWR5IHNpZ25hbGVkLCByZW1vdmUgaXQgZnJvbSB0 aGUgbGlzdC4gICovCiAgICAgICBpZiAocC0+cmF3X3N0YXR1c19uZXcpCiAJdXBkYXRlX3N0 YXR1cyAocCk7CkBAIC02MTY5LDM1ICs2MTgwLDM3IEBACiAgIHJldHVybiBwcm9jZXNzOwog fQogDAorI2lmZGVmIFNJR0NITEQKKwogLyogSWYgdGhlIHN0YXR1cyBvZiB0aGUgcHJvY2Vz cyBERVNJUkVEIGhhcyBjaGFuZ2VkLCByZXR1cm4gdHJ1ZSBhbmQKLSAgIHNldCAqU1RBVFVT IHRvIGl0cyBleGl0IHN0YXR1czsgb3RoZXJ3aXNlLCByZXR1cm4gZmFsc2UuCi0gICBJZiBI QVZFIGlzIG5vbm5lZ2F0aXZlLCBhc3N1bWUgdGhhdCBIQVZFID0gd2FpdHBpZCAoSEFWRSwg U1RBVFVTLCAuLi4pCi0gICBoYXMgYWxyZWFkeSBiZWVuIGludm9rZWQsIGFuZCBkbyBub3Qg aW52b2tlIHdhaXRwaWQgYWdhaW4uICAqLworICAgc2V0ICpTVEFUVVMgdG8gaXRzIGV4aXQg c3RhdHVzLiAgT3RoZXJ3aXNlLCByZXR1cm4gZmFsc2UuICBVc2UKKyAgIE9QVElPTlMgYXMg ZXh0cmEgb3B0aW9ucyB3aGVuIGludm9raW5nIHdhaXRwaWQuICBERVNJUkVEIG11c3QgYmUg YQorICAgY2hpbGQgcHJvY2VzcyB0aGF0IGhhcyBub3QgYmVlbiByZWFwZWQuICAqLwogCiBz dGF0aWMgYm9vbAotcHJvY2Vzc19zdGF0dXNfcmV0cmlldmVkIChwaWRfdCBkZXNpcmVkLCBw aWRfdCBoYXZlLCBpbnQgKnN0YXR1cykKK3Byb2Nlc3Nfc3RhdHVzX3JldHJpZXZlZCAocGlk X3QgZGVzaXJlZCwgaW50ICpzdGF0dXMsIGludCBvcHRpb25zKQogewotICBpZiAoaGF2ZSA8 IDApCisgIC8qIEludm9rZSB3YWl0cGlkIG9ubHkgd2l0aCBhIGtub3duIHByb2Nlc3MgSUQ7 IGRvIG5vdCBpbnZva2UKKyAgICAgd2FpdHBpZCB3aXRoIGEgbm9ucG9zaXRpdmUgYXJndW1l bnQuICBPdGhlcndpc2UsIEVtYWNzIG1pZ2h0CisgICAgIHJlYXAgYW4gdW53YW50ZWQgcHJv Y2VzcyBieSBtaXN0YWtlLiAgRm9yIGV4YW1wbGUsIGludm9raW5nCisgICAgIHdhaXRwaWQg KC0xLCAuLi4pIGNhbiBtZXNzIHVwIGdsaWIgYnkgcmVhcGluZyBnbGliJ3Mgc3VicHJvY2Vz c2VzLAorICAgICBzbyB0aGF0IGFub3RoZXIgdGhyZWFkIHJ1bm5pbmcgZ2xpYiB3b24ndCBm aW5kIHRoZW0uICAqLworICBlYXNzZXJ0ICgwIDwgZGVzaXJlZCk7CisKKyAgd2hpbGUgKDEp CiAgICAgewotICAgICAgLyogSW52b2tlIHdhaXRwaWQgb25seSB3aXRoIGEga25vd24gcHJv Y2VzcyBJRDsgZG8gbm90IGludm9rZQotCSB3YWl0cGlkIHdpdGggYSBub25wb3NpdGl2ZSBh cmd1bWVudC4gIE90aGVyd2lzZSwgRW1hY3MgbWlnaHQKLQkgcmVhcCBhbiB1bndhbnRlZCBw cm9jZXNzIGJ5IG1pc3Rha2UuICBGb3IgZXhhbXBsZSwgaW52b2tpbmcKLQkgd2FpdHBpZCAo LTEsIC4uLikgY2FuIG1lc3MgdXAgZ2xpYiBieSByZWFwaW5nIGdsaWIncyBzdWJwcm9jZXNz ZXMsCi0JIHNvIHRoYXQgYW5vdGhlciB0aHJlYWQgcnVubmluZyBnbGliIHdvbid0IGZpbmQg dGhlbS4gICovCi0gICAgICBkbwotCWhhdmUgPSB3YWl0cGlkIChkZXNpcmVkLCBzdGF0dXMs IFdOT0hBTkcgfCBXVU5UUkFDRUQpOwotICAgICAgd2hpbGUgKGhhdmUgPCAwICYmIGVycm5v ID09IEVJTlRSKTsKKyAgICAgIHBpZF90IHBpZCA9IHdhaXRwaWQgKGRlc2lyZWQsIHN0YXR1 cywgV05PSEFORyB8IG9wdGlvbnMpOworICAgICAgaWYgKDAgPD0gcGlkKQorCXJldHVybiAw IDwgcGlkOworICAgICAgaWYgKGVycm5vID09IEVDSElMRCkKKwlyZXR1cm4gMDsKKyAgICAg IGVhc3NlcnQgKGVycm5vID09IEVJTlRSKTsKICAgICB9Ci0KLSAgcmV0dXJuIGhhdmUgPT0g ZGVzaXJlZDsKIH0KIAotLyogSWYgUElEIGlzIG5vbm5lZ2F0aXZlLCB0aGUgY2hpbGQgcHJv Y2VzcyBQSUQgd2l0aCB3YWl0IHN0YXR1cyBXIGhhcwotICAgY2hhbmdlZCBpdHMgc3RhdHVz OyByZWNvcmQgdGhpcyBhbmQgcmV0dXJuIHRydWUuCi0KLSAgIElmIFBJRCBpcyBuZWdhdGl2 ZSwgaWdub3JlIFcsIGFuZCBsb29rIGZvciBrbm93biBjaGlsZCBwcm9jZXNzZXMKLSAgIG9m IEVtYWNzIHdob3NlIHN0YXR1cyBoYXZlIGNoYW5nZWQuICBGb3IgZWFjaCBvbmUgZm91bmQs IHJlY29yZCBpdHMgbmV3Ci0gICBzdGF0dXMuCisvKiBIYW5kbGUgYSBTSUdDSExEIHNpZ25h bCBieSBsb29raW5nIGZvciBrbm93biBjaGlsZCBwcm9jZXNzZXMgb2YKKyAgIEVtYWNzIHdo b3NlIHN0YXR1cyBoYXZlIGNoYW5nZWQuICBGb3IgZWFjaCBvbmUgZm91bmQsIHJlY29yZCBp dHMKKyAgIG5ldyBzdGF0dXMuCiAKICAgIEFsbCB3ZSBkbyBpcyBjaGFuZ2UgdGhlIHN0YXR1 czsgd2UgZG8gbm90IHJ1biBzZW50aW5lbHMgb3IgcHJpbnQKICAgIG5vdGlmaWNhdGlvbnMu ICBUaGF0IGlzIHNhdmVkIGZvciB0aGUgbmV4dCB0aW1lIGtleWJvYXJkIGlucHV0IGlzCkBA IC02MjIwLDIwICs2MjMzLDE2IEBACiAgICAqKiBNYWxsb2MgV0FSTklORzogVGhpcyBzaG91 bGQgbmV2ZXIgY2FsbCBtYWxsb2MgZWl0aGVyIGRpcmVjdGx5IG9yCiAgICBpbmRpcmVjdGx5 OyBpZiBpdCBkb2VzLCB0aGF0IGlzIGEgYnVnICAqLwogCi12b2lkCi1yZWNvcmRfY2hpbGRf c3RhdHVzX2NoYW5nZSAocGlkX3QgcGlkLCBpbnQgdykKK3N0YXRpYyB2b2lkCitoYW5kbGVf Y2hpbGRfc2lnbmFsIChpbnQgc2lnKQogewotI2lmZGVmIFNJR0NITEQKLQotICAvKiBSZWNv cmQgYXQgbW9zdCBvbmUgY2hpbGQgb25seSBpZiB3ZSBhbHJlYWR5IGtub3cgb25lIGNoaWxk IHRoYXQKLSAgICAgaGFzIGV4aXRlZC4gICovCi0gIGJvb2wgcmVjb3JkX2F0X21vc3Rfb25l X2NoaWxkID0gMCA8PSBwaWQ7Ci0KICAgTGlzcF9PYmplY3QgdGFpbDsKKyAgaW50IHN0YXR1 czsKIAogICAvKiBGaW5kIHRoZSBwcm9jZXNzIHRoYXQgc2lnbmFsZWQgdXMsIGFuZCByZWNv cmQgaXRzIHN0YXR1cy4gICovCiAKLSAgLyogVGhlIHByb2Nlc3MgY2FuIGhhdmUgYmVlbiBk ZWxldGVkIGJ5IEZkZWxldGVfcHJvY2Vzcy4gICovCisgIC8qIFRoZSBwcm9jZXNzIGNhbiBo YXZlIGJlZW4gZGVsZXRlZCBieSBGZGVsZXRlX3Byb2Nlc3MsIG9yIGhhdmUKKyAgICAgYmVl biBzdGFydGVkIGFzeW5jaHJvbm91c2x5IGJ5IEZjYWxsX3Byb2Nlc3MuICAqLwogICBmb3Ig KHRhaWwgPSBkZWxldGVkX3BpZF9saXN0OyBDT05TUCAodGFpbCk7IHRhaWwgPSBYQ0RSICh0 YWlsKSkKICAgICB7CiAgICAgICBib29sIGFsbF9waWRzX2FyZV9maXhudW1zCkBAIC02MjQ3 LDEyICs2MjU2LDggQEAKIAkgICAgZGVsZXRlZF9waWQgPSBYSU5UICh4cGlkKTsKIAkgIGVs c2UKIAkgICAgZGVsZXRlZF9waWQgPSBYRkxPQVRfREFUQSAoeHBpZCk7Ci0JICBpZiAocHJv Y2Vzc19zdGF0dXNfcmV0cmlldmVkIChkZWxldGVkX3BpZCwgcGlkLCAmdykpCi0JICAgIHsK LQkgICAgICBYU0VUQ0FSICh0YWlsLCBRbmlsKTsKLQkgICAgICBpZiAocmVjb3JkX2F0X21v c3Rfb25lX2NoaWxkKQotCQlyZXR1cm47Ci0JICAgIH0KKwkgIGlmIChwcm9jZXNzX3N0YXR1 c19yZXRyaWV2ZWQgKGRlbGV0ZWRfcGlkLCAmc3RhdHVzLCAwKSkKKwkgICAgWFNFVENBUiAo dGFpbCwgUW5pbCk7CiAJfQogICAgIH0KIApAQCAtNjI2MSwxNSArNjI2NiwxNiBAQAogICAg IHsKICAgICAgIExpc3BfT2JqZWN0IHByb2MgPSBYQ0RSIChYQ0FSICh0YWlsKSk7CiAgICAg ICBzdHJ1Y3QgTGlzcF9Qcm9jZXNzICpwID0gWFBST0NFU1MgKHByb2MpOwotICAgICAgaWYg KHAtPmFsaXZlICYmIHByb2Nlc3Nfc3RhdHVzX3JldHJpZXZlZCAocC0+cGlkLCBwaWQsICZ3 KSkKKworICAgICAgaWYgKHAtPmFsaXZlICYmIHByb2Nlc3Nfc3RhdHVzX3JldHJpZXZlZCAo cC0+cGlkLCAmc3RhdHVzLCBXVU5UUkFDRUQpKQogCXsKIAkgIC8qIENoYW5nZSB0aGUgc3Rh dHVzIG9mIHRoZSBwcm9jZXNzIHRoYXQgd2FzIGZvdW5kLiAgKi8KIAkgIHAtPnRpY2sgPSAr K3Byb2Nlc3NfdGljazsKLQkgIHAtPnJhd19zdGF0dXMgPSB3OworCSAgcC0+cmF3X3N0YXR1 cyA9IHN0YXR1czsKIAkgIHAtPnJhd19zdGF0dXNfbmV3ID0gMTsKIAogCSAgLyogSWYgcHJv Y2VzcyBoYXMgdGVybWluYXRlZCwgc3RvcCB3YWl0aW5nIGZvciBpdHMgb3V0cHV0LiAgKi8K LQkgIGlmIChXSUZTSUdOQUxFRCAodykgfHwgV0lGRVhJVEVEICh3KSkKKwkgIGlmIChXSUZT SUdOQUxFRCAoc3RhdHVzKSB8fCBXSUZFWElURUQgKHN0YXR1cykpCiAJICAgIHsKIAkgICAg ICBpbnQgY2xlYXJfZGVzY19mbGFnID0gMDsKIAkgICAgICBwLT5hbGl2ZSA9IDA7CkBAIC02 Mjg4LDM5ICs2Mjk0LDggQEAKIAkgICAgIGxvb2sgYXJvdW5kLiAgKi8KIAkgIGlmIChpbnB1 dF9hdmFpbGFibGVfY2xlYXJfdGltZSkKIAkgICAgKmlucHV0X2F2YWlsYWJsZV9jbGVhcl90 aW1lID0gbWFrZV9lbWFjc190aW1lICgwLCAwKTsKLQotCSAgaWYgKHJlY29yZF9hdF9tb3N0 X29uZV9jaGlsZCkKLQkgICAgcmV0dXJuOwogCX0KICAgICB9Ci0KLSAgaWYgKDAgPD0gcGlk KQotICAgIHsKLSAgICAgIC8qIFRoZSBjYWxsZXIgc3VjY2Vzc2Z1bGx5IHdhaXRlZCBmb3Ig YSBwaWQgYnV0IG5vIGFzeW5jaHJvbm91cwotCSBwcm9jZXNzIHdhcyBmb3VuZCBmb3IgaXQs IHNvIHRoaXMgaXMgYSBzeW5jaHJvbm91cyBwcm9jZXNzLiAgKi8KLQotICAgICAgc3luY2hf cHJvY2Vzc19hbGl2ZSA9IDA7Ci0KLSAgICAgIC8qIFJlcG9ydCB0aGUgc3RhdHVzIG9mIHRo ZSBzeW5jaHJvbm91cyBwcm9jZXNzLiAgKi8KLSAgICAgIGlmIChXSUZFWElURUQgKHcpKQot CXN5bmNoX3Byb2Nlc3NfcmV0Y29kZSA9IFdFWElUU1RBVFVTICh3KTsKLSAgICAgIGVsc2Ug aWYgKFdJRlNJR05BTEVEICh3KSkKLQlzeW5jaF9wcm9jZXNzX3Rlcm1zaWcgPSBXVEVSTVNJ RyAodyk7Ci0KLSAgICAgIC8qIFRlbGwgd2FpdF9yZWFkaW5nX3Byb2Nlc3Nfb3V0cHV0IHRo YXQgaXQgbmVlZHMgdG8gd2FrZSB1cCBhbmQKLQkgbG9vayBhcm91bmQuICAqLwotICAgICAg aWYgKGlucHV0X2F2YWlsYWJsZV9jbGVhcl90aW1lKQotCSppbnB1dF9hdmFpbGFibGVfY2xl YXJfdGltZSA9IG1ha2VfZW1hY3NfdGltZSAoMCwgMCk7Ci0gICAgfQotI2VuZGlmCi19Ci0K LSNpZmRlZiBTSUdDSExECi0KLXN0YXRpYyB2b2lkCi1oYW5kbGVfY2hpbGRfc2lnbmFsIChp bnQgc2lnKQotewotICByZWNvcmRfY2hpbGRfc3RhdHVzX2NoYW5nZSAoLTEsIDApOwogfQog CiBzdGF0aWMgdm9pZAoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy9wcm9jZXNzLmgnCi0tLSBz cmMvcHJvY2Vzcy5oCTIwMTItMTEtMjQgMDE6NTc6MDkgKzAwMDAKKysrIHNyYy9wcm9jZXNz LmgJMjAxMi0xMS0yNiAyMjowNjoyNCArMDAwMApAQCAtMTg1LDIzICsxODUsNiBAQAogfQog I2VuZGlmCiAKLS8qIFRydWUgaWYgd2UgYXJlIGFib3V0IHRvIGZvcmsgb2ZmIGEgc3luY2hy b25vdXMgcHJvY2VzcyBvciBpZiB3ZQotICAgYXJlIHdhaXRpbmcgZm9yIGl0LiAgKi8KLWV4 dGVybiBib29sIHN5bmNoX3Byb2Nlc3NfYWxpdmU7Ci0KLS8qIENvbW11bmljYXRlIGV4aXQg c3RhdHVzIG9mIHN5bmMgcHJvY2VzcyB0byBmcm9tIHNpZ2NobGRfaGFuZGxlcgotICAgdG8g RmNhbGxfcHJvY2Vzcy4gICovCi0KLS8qIE5vbnplcm8gPT4gdGhpcyBpcyBhIHN0cmluZyBl eHBsYWluaW5nIGRlYXRoIG9mIHN5bmNocm9ub3VzIHN1YnByb2Nlc3MuICAqLwotZXh0ZXJu IGNvbnN0IGNoYXIgKnN5bmNoX3Byb2Nlc3NfZGVhdGg7Ci0KLS8qIE5vbnplcm8gPT4gdGhp cyBpcyB0aGUgc2lnbmFsIG51bWJlciB0aGF0IHRlcm1pbmF0ZWQgdGhlIHN1YnByb2Nlc3Mu ICAqLwotZXh0ZXJuIGludCBzeW5jaF9wcm9jZXNzX3Rlcm1zaWc7Ci0KLS8qIElmIHN5bmNo X3Byb2Nlc3NfZGVhdGggaXMgemVybywKLSAgIHRoaXMgaXMgZXhpdCBjb2RlIG9mIHN5bmNo cm9ub3VzIHN1YnByb2Nlc3MuICAqLwotZXh0ZXJuIGludCBzeW5jaF9wcm9jZXNzX3JldGNv ZGU7Ci0KIC8qIE5vbnplcm8gbWVhbnMgZG9uJ3QgcnVuIHByb2Nlc3Mgc2VudGluZWxzLiAg VGhpcyBpcyB1c2VkCiAgICB3aGVuIGV4aXRpbmcuICAqLwogZXh0ZXJuIGludCBpbmhpYml0 X3NlbnRpbmVsczsKCj09PSBtb2RpZmllZCBmaWxlICdzcmMvc3lzZGVwLmMnCi0tLSBzcmMv c3lzZGVwLmMJMjAxMi0xMS0yNSAwNzo1MDo1NSArMDAwMAorKysgc3JjL3N5c2RlcC5jCTIw MTItMTEtMjYgMjI6MDY6MjQgKzAwMDAKQEAgLTI2NiwyMSArMjY2LDI3IEBACiAKICNpZm5k ZWYgTVNET1MKIAotc3RhdGljIHZvaWQKLXdhaXRfZm9yX3Rlcm1pbmF0aW9uXzEgKHBpZF90 IHBpZCwgaW50IGludGVycnVwdGlibGUpCisvKiBXYWl0IGZvciBzdWJwcm9jZXNzIHdpdGgg cHJvY2VzcyBpZCBQSUQgdG8gdGVybWluYXRlLgorICAgSWYgU1RBVFVTIGlzIG5vbi1udWxs LCBzdG9yZSB0aGUgd2FpdHBpZC1zdHlsZSBleGl0IHN0YXR1cyBpbnRvICpTVEFUVVMuCisg ICBJZiBJTlRFUlJVUFRJQkxFLCB0aGlzIGZ1bmN0aW9uIGlzIGludGVycnVwdGlibGUgYnkg YSBzaWduYWwuCisKKyAgIFRoaXMgZnVuY3Rpb24gY2FuIGJlIGNhbGxlZCB0d2ljZSBmb3Ig dGhlIHNhbWUgc3VicHJvY2Vzcywgc28gbG9uZworICAgYXMgbm8gb3RoZXIgc3VicHJvY2Vz cyBpcyBjcmVhdGVkICh2aWEgZm9yayBldGMuKSBiZXR3ZWVuIHRoZSB0d28KKyAgIGNhbGxz IChhcyB0aGUgb3RoZXIgc3VicHJvY2VzcyBtaWdodCBiZSBhc3NpZ25lZCB0aGUgc2FtZSBw aWQpLgorICAgRG91YmxlIGNhbGxzIGNhbiBvY2N1ciBkdWUgdG8gcmFjZSBjb25kaXRpb25z IGludm9sdmluZyBzaWduYWxzCisgICBhcnJpdmluZyB3aGVuIHdhaXRpbmcgZm9yIGEgc3lu Y2hyb25vdXMgcHJvY2VzcyB0byBleGl0OyB3aGVuIHRoaXMKKyAgIGhhcHBlbnMsIHRoZSBs YXRlciAoY2xlYW51cCkgY2FsbCBzaG91bGQgdXNlIGEgbnVsbCBTVEFUVVMgdG8KKyAgIGlu ZGljYXRlIHRoYXQgdGhlIHN0YXR1cyBpcyBub3QgbmVlZGVkLiAgKi8KK3ZvaWQKK3dhaXRf Zm9yX3Rlcm1pbmF0aW9uIChwaWRfdCBwaWQsIGludCAqc3RhdHVzLCBib29sIGludGVycnVw dGlibGUpCiB7Ci0gIHdoaWxlICgxKQorICBpbnQgZHVtbXk7CisKKyAgd2hpbGUgKHdhaXRw aWQgKHBpZCwgc3RhdHVzID8gc3RhdHVzIDogJmR1bW15LCAwKSA8IDApCiAgICAgewotICAg ICAgaW50IHN0YXR1czsKLSAgICAgIGludCB3YWl0X3Jlc3VsdCA9IHdhaXRwaWQgKHBpZCwg JnN0YXR1cywgMCk7Ci0gICAgICBpZiAod2FpdF9yZXN1bHQgPCAwKQotCXsKLQkgIGlmIChl cnJubyAhPSBFSU5UUikKLQkgICAgYnJlYWs7Ci0JfQotICAgICAgZWxzZQotCXsKLQkgIHJl Y29yZF9jaGlsZF9zdGF0dXNfY2hhbmdlICh3YWl0X3Jlc3VsdCwgc3RhdHVzKTsKKyAgICAg IGlmIChlcnJubyAhPSBFSU5UUikKKwl7CisJICBlYXNzZXJ0ICghIHN0YXR1cyk7CiAJICBi cmVhazsKIAl9CiAKQEAgLTI4OSwyMiArMjk1LDExIEBACiAgICAgICBpZiAoaW50ZXJydXB0 aWJsZSkKIAlRVUlUOwogICAgIH0KLX0KLQotLyogV2FpdCBmb3Igc3VicHJvY2VzcyB3aXRo IHByb2Nlc3MgaWQgYHBpZCcgdG8gdGVybWluYXRlIGFuZAotICAgbWFrZSBzdXJlIGl0IHdp bGwgZ2V0IGVsaW1pbmF0ZWQgKG5vdCByZW1haW4gZm9yZXZlciBhcyBhIHpvbWJpZSkgKi8K LQotdm9pZAotd2FpdF9mb3JfdGVybWluYXRpb24gKHBpZF90IHBpZCkKLXsKLSAgd2FpdF9m b3JfdGVybWluYXRpb25fMSAocGlkLCAwKTsKLX0KLQotLyogTGlrZSB0aGUgYWJvdmUsIGJ1 dCBhbGxvdyBrZXlib2FyZCBpbnRlcnJ1cHRpb24uICovCi12b2lkCi1pbnRlcnJ1cHRpYmxl X3dhaXRfZm9yX3Rlcm1pbmF0aW9uIChwaWRfdCBwaWQpCi17Ci0gIHdhaXRfZm9yX3Rlcm1p bmF0aW9uXzEgKHBpZCwgMSk7CisKKyAgLyogVGVsbCB3YWl0X3JlYWRpbmdfcHJvY2Vzc19v dXRwdXQgdGhhdCBpdCBuZWVkcyB0byB3YWtlIHVwIGFuZAorICAgICBsb29rIGFyb3VuZC4g ICovCisgIGlmIChpbnB1dF9hdmFpbGFibGVfY2xlYXJfdGltZSkKKyAgICAqaW5wdXRfYXZh aWxhYmxlX2NsZWFyX3RpbWUgPSBtYWtlX2VtYWNzX3RpbWUgKDAsIDApOwogfQogCiAvKgpA QCAtNDU0LDYgKzQ0OSw3IEBACiAgIGNoYXIgb2xkd2RbTUFYUEFUSExFTisxXTsgLyogRml4 ZWQgbGVuZ3RoIGlzIHNhZmUgb24gTVNET1MuICAqLwogI2VuZGlmCiAgIHBpZF90IHBpZDsK KyAgaW50IHN0YXR1czsKICAgc3RydWN0IHNhdmVfc2lnbmFsIHNhdmVkX2hhbmRsZXJzWzVd OwogICBMaXNwX09iamVjdCBkaXI7CiAgIHVuc2lnbmVkIGNoYXIgKnZvbGF0aWxlIHN0cl92 b2xhdGlsZSA9IDA7CkBAIC00OTEsNyArNDg3LDYgQEAKICNpZmRlZiBET1NfTlQKICAgcGlk ID0gMDsKICAgc2F2ZV9zaWduYWxfaGFuZGxlcnMgKHNhdmVkX2hhbmRsZXJzKTsKLSAgc3lu Y2hfcHJvY2Vzc19hbGl2ZSA9IDE7CiAjZWxzZQogICBwaWQgPSB2Zm9yayAoKTsKICAgaWYg KHBpZCA9PSAtMSkKQEAgLTU2MCwxNCArNTU1LDEyIEBACiAgIC8qIERvIHRoaXMgbm93IGlm IHdlIGRpZCBub3QgZG8gaXQgYmVmb3JlLiAgKi8KICNpZm5kZWYgTVNET1MKICAgc2F2ZV9z aWduYWxfaGFuZGxlcnMgKHNhdmVkX2hhbmRsZXJzKTsKLSAgc3luY2hfcHJvY2Vzc19hbGl2 ZSA9IDE7CiAjZW5kaWYKIAogI2lmbmRlZiBET1NfTlQKLSAgd2FpdF9mb3JfdGVybWluYXRp b24gKHBpZCk7CisgIHdhaXRfZm9yX3Rlcm1pbmF0aW9uIChwaWQsICZzdGF0dXMsIDApOwog I2VuZGlmCiAgIHJlc3RvcmVfc2lnbmFsX2hhbmRsZXJzIChzYXZlZF9oYW5kbGVycyk7Ci0g IHN5bmNoX3Byb2Nlc3NfYWxpdmUgPSAwOwogfQogCiBzdGF0aWMgdm9pZAoKPT09IG1vZGlm aWVkIGZpbGUgJ3NyYy9zeXN3YWl0LmgnCi0tLSBzcmMvc3lzd2FpdC5oCTIwMTItMDktMjMg MjI6MjU6MjIgKzAwMDAKKysrIHNyYy9zeXN3YWl0LmgJMjAxMi0xMS0yNiAyMjowNjoyNCAr MDAwMApAQCAtMjMsNiArMjMsNyBAQAogI2lmbmRlZiBFTUFDU19TWVNXQUlUX0gKICNkZWZp bmUgRU1BQ1NfU1lTV0FJVF9ICiAKKyNpbmNsdWRlIDxzdGRib29sLmg+CiAjaW5jbHVkZSA8 c3lzL3R5cGVzLmg+CiAKICNpZmRlZiBIQVZFX1NZU19XQUlUX0gJLyogV2UgaGF2ZSBzeXMv d2FpdC5oIHdpdGggUE9TSVhvaWQgZGVmaW5pdGlvbnMuICovCkBAIC01MiwxMCArNTMsOSBA QAogI2VuZGlmCiAKIC8qIERlZmluZWQgaW4gcHJvY2Vzcy5jLiAgKi8KLWV4dGVybiB2b2lk IHJlY29yZF9jaGlsZF9zdGF0dXNfY2hhbmdlIChwaWRfdCwgaW50KTsKK2V4dGVybiB2b2lk IHJlY29yZF9kZWxldGVkX3BpZCAocGlkX3QpOwogCiAvKiBEZWZpbmVkIGluIHN5c2RlcC5j LiAgKi8KLWV4dGVybiB2b2lkIHdhaXRfZm9yX3Rlcm1pbmF0aW9uIChwaWRfdCk7Ci1leHRl cm4gdm9pZCBpbnRlcnJ1cHRpYmxlX3dhaXRfZm9yX3Rlcm1pbmF0aW9uIChwaWRfdCk7Citl eHRlcm4gdm9pZCB3YWl0X2Zvcl90ZXJtaW5hdGlvbiAocGlkX3QsIGludCAqLCBib29sKTsK IAogI2VuZGlmIC8qIEVNQUNTX1NZU1dBSVRfSCAqLwoKPT09IG1vZGlmaWVkIGZpbGUgJ3Ny Yy93MzJwcm9jLmMnCi0tLSBzcmMvdzMycHJvYy5jCTIwMTItMTEtMjQgMDE6NTc6MDkgKzAw MDAKKysrIHNyYy93MzJwcm9jLmMJMjAxMi0xMS0yNiAyMjowNjoyNCArMDAwMApAQCAtMTI3 MywzNCArMTI3Myw3IEBACiAgIERlYlByaW50ICgoIldhaXQgc2lnbmFsZWQgd2l0aCBwcm9j ZXNzIHBpZCAlZFxuIiwgY3AtPnBpZCkpOwogI2VuZGlmCiAKLSAgaWYgKHN0YXR1cykKLSAg ICB7Ci0gICAgICAqc3RhdHVzID0gcmV0dmFsOwotICAgIH0KLSAgZWxzZSBpZiAoc3luY2hf cHJvY2Vzc19hbGl2ZSkKLSAgICB7Ci0gICAgICBzeW5jaF9wcm9jZXNzX2FsaXZlID0gMDsK LQotICAgICAgLyogUmVwb3J0IHRoZSBzdGF0dXMgb2YgdGhlIHN5bmNocm9ub3VzIHByb2Nl c3MuICAqLwotICAgICAgaWYgKFdJRkVYSVRFRCAocmV0dmFsKSkKLQlzeW5jaF9wcm9jZXNz X3JldGNvZGUgPSBXRVhJVFNUQVRVUyAocmV0dmFsKTsKLSAgICAgIGVsc2UgaWYgKFdJRlNJ R05BTEVEIChyZXR2YWwpKQotCXsKLQkgIGludCBjb2RlID0gV1RFUk1TSUcgKHJldHZhbCk7 Ci0JICBjb25zdCBjaGFyICpzaWduYW1lOwotCi0JICBzeW5jaHJvbml6ZV9zeXN0ZW1fbWVz c2FnZXNfbG9jYWxlICgpOwotCSAgc2lnbmFtZSA9IHN0cnNpZ25hbCAoY29kZSk7Ci0KLQkg IGlmIChzaWduYW1lID09IDApCi0JICAgIHNpZ25hbWUgPSAidW5rbm93biI7Ci0KLQkgIHN5 bmNoX3Byb2Nlc3NfZGVhdGggPSBzaWduYW1lOwotCX0KLQotICAgICAgcmVhcF9zdWJwcm9j ZXNzIChjcCk7Ci0gICAgfQotCisgICpzdGF0dXMgPSByZXR2YWw7CiAgIHJlYXBfc3VicHJv Y2VzcyAoY3ApOwogCiAgIHJldHVybiBwaWQ7Cgo= --------------040502050800060804060908-- From debbugs-submit-bounces@debbugs.gnu.org Mon Nov 26 18:43:18 2012 Received: (at control) by debbugs.gnu.org; 26 Nov 2012 23:43:18 +0000 Received: from localhost ([127.0.0.1]:40679 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Td8Kb-0002R4-S2 for submit@debbugs.gnu.org; Mon, 26 Nov 2012 18:43:18 -0500 Received: from smtp.cs.ucla.edu ([131.179.128.62]:40186) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Td8KZ-0002Qu-G7 for control@debbugs.gnu.org; Mon, 26 Nov 2012 18:43:16 -0500 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 6F0A8A60001 for ; Mon, 26 Nov 2012 15:41:29 -0800 (PST) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id hbSMp9fD8Ln5 for ; Mon, 26 Nov 2012 15:41:29 -0800 (PST) Received: from [192.168.1.3] (pool-71-189-154-249.lsanca.fios.verizon.net [71.189.154.249]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 2D83B39E8106 for ; Mon, 26 Nov 2012 15:41:29 -0800 (PST) Message-ID: <50B3FE21.5060709@cs.ucla.edu> Date: Mon, 26 Nov 2012 15:41:21 -0800 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:17.0) Gecko/17.0 Thunderbird/17.0 MIME-Version: 1.0 To: control@debbugs.gnu.org Subject: patches for 12980, 9488 are now available Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: control X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.9 (-) tags 12980 patch tags 9488 patch thanks From unknown Sat Jun 14 19:12:50 2025 X-Loop: help-debbugs@gnu.org Subject: bug#9488: 24.3.50; Zombie process left after call-process Resent-From: Eli Zaretskii Original-Sender: debbugs-submit-bounces@debbugs.gnu.org Resent-CC: bug-gnu-emacs@gnu.org Resent-Date: Tue, 27 Nov 2012 16:04:01 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 9488 X-GNU-PR-Package: emacs X-GNU-PR-Keywords: patch To: Paul Eggert Cc: 9488@debbugs.gnu.org, hanche@math.ntnu.no, 12980@debbugs.gnu.org Reply-To: Eli Zaretskii Received: via spool by 9488-submit@debbugs.gnu.org id=B9488.135403218420385 (code B ref 9488); Tue, 27 Nov 2012 16:04:01 +0000 Received: (at 9488) by debbugs.gnu.org; 27 Nov 2012 16:03:04 +0000 Received: from localhost ([127.0.0.1]:41894 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1TdNcj-0005IV-JO for submit@debbugs.gnu.org; Tue, 27 Nov 2012 11:03:02 -0500 Received: from mtaout20.012.net.il ([80.179.55.166]:45912) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1TdNcf-0005IF-Cz; Tue, 27 Nov 2012 11:02:59 -0500 Received: from conversion-daemon.a-mtaout20.012.net.il by a-mtaout20.012.net.il (HyperSendmail v2007.08) id <0ME500K00LQBCV00@a-mtaout20.012.net.il>; Tue, 27 Nov 2012 18:00:42 +0200 (IST) Received: from HOME-C4E4A596F7 ([87.69.4.28]) by a-mtaout20.012.net.il (HyperSendmail v2007.08) with ESMTPA id <0ME500K8ELT58P30@a-mtaout20.012.net.il>; Tue, 27 Nov 2012 18:00:42 +0200 (IST) Date: Tue, 27 Nov 2012 18:00:56 +0200 From: Eli Zaretskii In-reply-to: <50B3EF71.3020805@cs.ucla.edu> X-012-Sender: halo1@inter.net.il Message-id: <83ehjfxcg7.fsf@gnu.org> References: <50B3EF71.3020805@cs.ucla.edu> X-Spam-Score: 1.5 (+) X-Spam-Report: Spam detection software, running on the system "debbugs.gnu.org", has identified this incoming email as possible spam. The original message has been attached to this so you can view it (if it isn't spam) or label similar future email. If you have any questions, see the administrator of that system for details. Content preview: > Date: Mon, 26 Nov 2012 14:38:41 -0800 > From: Paul Eggert > CC: 12980@debbugs.gnu.org, Eli Zaretskii , > 9488@debbugs.gnu.org > > Harald, thanks for the bug report. This part of Emacs is a bit > messy, but I hacked away at it and came up with > the attached proposed patch. > > This patch touches some code for Microsoft platforms > so I'm CC'ing this to Eli. [...] Content analysis details: (1.5 points, 10.0 required) pts rule name description ---- ---------------------- -------------------------------------------------- -0.0 RCVD_IN_DNSWL_NONE RBL: Sender listed at http://www.dnswl.org/, no trust [80.179.55.166 listed in list.dnswl.org] 0.7 SPF_SOFTFAIL SPF: sender does not match SPF record (softfail) 0.8 BAYES_50 BODY: Bayes spam probability is 40 to 60% [score: 0.4959] X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.2 (-) > Date: Mon, 26 Nov 2012 14:38:41 -0800 > From: Paul Eggert > CC: 12980@debbugs.gnu.org, Eli Zaretskii , > 9488@debbugs.gnu.org > > Harald, thanks for the bug report. This part of Emacs is a bit > messy, but I hacked away at it and came up with > the attached proposed patch. > > This patch touches some code for Microsoft platforms > so I'm CC'ing this to Eli. Thanks. > +/* Return true if CHILD is reapable. CHILD must be the process ID of > + a child process. As a side effect this function may reap CHILD, > + discarding its status, and therefore report that CHILD is not > + reapable. > + > + This function is intended for use after the caller was interrupted > + while trying to reap CHILD, and where the caller later tests > + whether CHILD was in fact reaped. The caller should not create > + another child process (via vfork, say) between the earlier attempt > + to reap CHILD and now, as that would cause a race if the newly > + created child process happened to have CHILD as its process-ID. */ I'm confused by this commentary, perhaps because it doesn't explain what is the definition of "reapable". The original naive interpretation (i.e. the child exited and its status is ready to be accessed) seems to contradict the latter part of the commentary, and also the fact that the function will return false both if waitpid returns a positive and a negative value. I would suggest to clarify this. > #ifdef MSDOS /* MW, July 1993 */ > /* Note that on MSDOS `child_setup' actually returns the child process > - exit status, not its PID, so we assign it to `synch_process_retcode' > - below. */ > + exit status, not its PID, so assign it to status below. */ > pid = child_setup (filefd, outfilefd, fd_error, (char **) new_argv, > 0, current_dir); > - > - /* Record that the synchronous process exited and note its > - termination status. */ > - synch_process_alive = 0; > - synch_process_retcode = pid; > - if (synch_process_retcode < 0) /* means it couldn't be exec'ed */ > - { > - synchronize_system_messages_locale (); > - synch_process_death = strerror (errno); > - } > + status = pid; The feature, whereby this function (call-process) could return a description of errno, is hereby lost. That's quite nasty in the MSDOS case, where errno is the only way to indicate to the user what happened, because the value of status in case of failure is always -1, which is not quite descriptive. Can we please not drop this feature on the floor? > + if (0 < pid) > + { > + if (INTEGERP (buffer)) > + record_deleted_pid (pid); > + else > + { > +#ifdef MSDOS > + /* MSDOS needs different cleanup information. */ > + cleanup_info_tail = build_string (tempfile ? tempfile : ""); > +#else > + cleanup_info_tail = INTEGER_TO_CONS (pid); > +#endif > + record_unwind_protect (call_process_cleanup, > + Fcons (Fcurrent_buffer (), > + Fcons (INTEGER_TO_CONS (fd[0]), > + cleanup_info_tail))); > + } > + } > + > + unblock_child_signal (); > unblock_input (); > > #endif /* not WINDOWSNT */ > @@ -658,17 +705,6 @@ > /* Enable sending signal if user quits below. */ > call_process_exited = 0; > > -#if defined (MSDOS) > - /* MSDOS needs different cleanup information. */ > - cleanup_info_tail = build_string (tempfile ? tempfile : ""); > -#else > - cleanup_info_tail = INTEGER_TO_CONS (pid); > -#endif /* not MSDOS */ > - record_unwind_protect (call_process_cleanup, > - Fcons (Fcurrent_buffer (), > - Fcons (INTEGER_TO_CONS (fd[0]), > - cleanup_info_tail))); > - This is wrong for MSDOS, because the temporary file is created before attempting to launch the process, and so it needs to be cleaned up even if we failed to launch the child process. > - if (synch_process_termsig) > + if (WIFSIGNALED (status)) > { > const char *signame; > > synchronize_system_messages_locale (); > - signame = strsignal (synch_process_termsig); > + signame = strsignal (WTERMSIG (status)); > > if (signame == 0) > signame = "unknown"; > > - synch_process_death = signame; > + return code_convert_string_norecord (build_string (signame), > + Vlocale_coding_system, 0); > } > > - if (synch_process_death) > - return code_convert_string_norecord (build_string (synch_process_death), > - Vlocale_coding_system, 0); > - return make_number (synch_process_retcode); > + eassert (WIFEXITED (status)); > + return make_number (WEXITSTATUS (status)); This seem to assume that the only trouble in call-process could be from some signal. Why is that true? > static bool > -process_status_retrieved (pid_t desired, pid_t have, int *status) > +process_status_retrieved (pid_t desired, int *status, int options) > { > - if (have < 0) > + /* Invoke waitpid only with a known process ID; do not invoke > + waitpid with a nonpositive argument. Otherwise, Emacs might > + reap an unwanted process by mistake. For example, invoking > + waitpid (-1, ...) can mess up glib by reaping glib's subprocesses, > + so that another thread running glib won't find them. */ > + eassert (0 < desired); > + > + while (1) > { > - /* Invoke waitpid only with a known process ID; do not invoke > - waitpid with a nonpositive argument. Otherwise, Emacs might > - reap an unwanted process by mistake. For example, invoking > - waitpid (-1, ...) can mess up glib by reaping glib's subprocesses, > - so that another thread running glib won't find them. */ > - do > - have = waitpid (desired, status, WNOHANG | WUNTRACED); > - while (have < 0 && errno == EINTR); > + pid_t pid = waitpid (desired, status, WNOHANG | options); > + if (0 <= pid) > + return 0 < pid; > + if (errno == ECHILD) > + return 0; > + eassert (errno == EINTR); Why is this eassert a good idea? We don't need to enforce the Posix spec at a price of crashing Emacs on users, do we? What bad things can happen if you see some other errno here? > --- src/w32proc.c 2012-11-24 01:57:09 +0000 > +++ src/w32proc.c 2012-11-26 22:06:24 +0000 > @@ -1273,34 +1273,7 @@ > DebPrint (("Wait signaled with process pid %d\n", cp->pid)); > #endif > > - if (status) > - { > - *status = retval; > - } > - else if (synch_process_alive) > - { > - synch_process_alive = 0; > - > - /* Report the status of the synchronous process. */ > - if (WIFEXITED (retval)) > - synch_process_retcode = WEXITSTATUS (retval); > - else if (WIFSIGNALED (retval)) > - { > - int code = WTERMSIG (retval); > - const char *signame; > - > - synchronize_system_messages_locale (); > - signame = strsignal (code); > - > - if (signame == 0) > - signame = "unknown"; > - > - synch_process_death = signame; > - } > - > - reap_subprocess (cp); > - } > - > + *status = retval; > reap_subprocess (cp); The condition testing that status is non-NULL must stay, because that argument can be NULL, even if Emacs currently never uses that option. I didn't see any other obvious problems. However, given the complexity of handling this, and the extent of changes in this changeset, it would be nice to have somewhere a commentary with an overview of how termination of child processes is handled. Reverse engineering that from the code is not really trivial. Would you please consider writing such an overview? TIA From unknown Sat Jun 14 19:12:50 2025 X-Loop: help-debbugs@gnu.org Subject: bug#9488: 24.3.50; Zombie process left after call-process Resent-From: Paul Eggert Original-Sender: debbugs-submit-bounces@debbugs.gnu.org Resent-CC: bug-gnu-emacs@gnu.org Resent-Date: Thu, 29 Nov 2012 02:33:02 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 9488 X-GNU-PR-Package: emacs X-GNU-PR-Keywords: patch To: Eli Zaretskii Cc: 9488@debbugs.gnu.org, hanche@math.ntnu.no, 12980@debbugs.gnu.org Received: via spool by 9488-submit@debbugs.gnu.org id=B9488.13541563402257 (code B ref 9488); Thu, 29 Nov 2012 02:33:02 +0000 Received: (at 9488) by debbugs.gnu.org; 29 Nov 2012 02:32:20 +0000 Received: from localhost ([127.0.0.1]:44341 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1TdtvF-0000aF-1l for submit@debbugs.gnu.org; Wed, 28 Nov 2012 21:32:19 -0500 Received: from smtp.cs.ucla.edu ([131.179.128.62]:58994) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Tdtv6-0000Zw-AT; Wed, 28 Nov 2012 21:32:13 -0500 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 5FB7A39E8105; Wed, 28 Nov 2012 18:30:10 -0800 (PST) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 8Dm0DiFeRMx8; Wed, 28 Nov 2012 18:30:08 -0800 (PST) Received: from [192.168.1.3] (pool-71-189-154-249.lsanca.fios.verizon.net [71.189.154.249]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 75CE139E8008; Wed, 28 Nov 2012 18:30:08 -0800 (PST) Message-ID: <50B6C8B0.3000403@cs.ucla.edu> Date: Wed, 28 Nov 2012 18:30:08 -0800 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:17.0) Gecko/17.0 Thunderbird/17.0 MIME-Version: 1.0 References: <50B3EF71.3020805@cs.ucla.edu> <83ehjfxcg7.fsf@gnu.org> In-Reply-To: <83ehjfxcg7.fsf@gnu.org> Content-Type: multipart/mixed; boundary="------------090006010900090003030103" X-Spam-Score: -4.6 (----) X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -4.6 (----) This is a multi-part message in MIME format. --------------090006010900090003030103 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit Eli, thanks for your review. I'm attaching a heavily-revised patch, which tries to take your comments into account, along with several other issues I noticed in my own analysis and testing. In response to your comments: On 11/27/2012 08:00 AM, Eli Zaretskii wrote: > I'm confused by this commentary The new patch removes that function and its associated commentary. > The feature, whereby this function (call-process) could return a > description of errno, is hereby lost. That's quite nasty in the MSDOS > case That feature is supported only by MS-DOS, right? On all other platforms an error is thrown. Anyway, the new patch attempts to preserve the MS-DOS behavior. > This is wrong for MSDOS, because the temporary file is created before > attempting to launch the process, and so it needs to be cleaned up > even if we failed to launch the child process. The new patch attempts to undo that change for MSDOS. > This seem to assume that the only trouble in call-process could be > from some signal. Why is that true? By the time that part of the code is reached, any other failures (e.g., fork failure) have already been diagnosed and an error would have been thrown or call-process would have returned before getting to that location. > Why is this eassert a good idea? We don't need to enforce the Posix > spec at a price of crashing Emacs on users, do we? What bad things > can happen if you see some other errno here? It's not a question of enforcing Posix semantics. It's a question of catching potentially serious internal programming errors in Emacs. That part of the code has been completely rewritten, so the details of the comment is moot. However, the new code has an "eassert (errno == EINTR)" in the new get_child_status function. I preceded that with a comment to try to help explain why the eassert is there. > The condition testing that status is non-NULL must stay, because that > argument can be NULL, even if Emacs currently never uses that option. OK, thanks, I did that. > it would be nice to have somewhere a commentary with an > overview of how termination of child processes is handled. I added some, before handle_child_signal. --------------090006010900090003030103 Content-Type: text/plain; charset=UTF-8; name="g_spawn_sync.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="g_spawn_sync.txt" PT09IG1vZGlmaWVkIGZpbGUgJ3NyYy9DaGFuZ2VMb2cnCi0tLSBzcmMvQ2hhbmdlTG9nCTIw MTItMTEtMjkgMDA6MzY6MjIgKzAwMDAKKysrIHNyYy9DaGFuZ2VMb2cJMjAxMi0xMS0yOSAw MjoyNDo0NSArMDAwMApAQCAtMSw1ICsxLDYyIEBACiAyMDEyLTExLTI5ICBQYXVsIEVnZ2Vy dCAgPGVnZ2VydEBjcy51Y2xhLmVkdT4KIAorCURvbid0IGxldCBjYWxsLXByb2Nlc3MgYmUg YSB6b21iaWUgZmFjdG9yeSAoQnVnIzEyOTgwKS4KKwlGaXhpbmcgdGhpcyBidWcgcmVxdWly ZWQgc29tZSBjbGVhbnVwIG9mIHRoZSBzaWduYWwtaGFuZGxpbmcgY29kZS4KKwlBcyBhIHNp ZGUgZWZmZWN0LCB0aGlzIGNoYW5nZSBhbHNvIGZpeGVzIGEgbG9uZ3N0YW5kaW5nIHJhcmUg cmFjZQorCWNvbmRpdGlvbiB3aGVyZWJ5IEVtYWNzIGNvdWxkIG1pc3Rha2VubHkga2lsbCB1 bnJlbGF0ZWQgcHJvY2Vzc2VzLAorCWFuZCBpdCBmaXhlcyBhIGJ1ZyB3aGVyZSBhIHNlY29u ZCBDLWcgZG9lcyBub3Qga2lsbCBhIHJlY2FsY2l0cmFudAorCXN5bmNocm9ub3VzIHByb2Nl c3MgaW4gR05VL0xpbnV4IGFuZCBzaW1pbGFyIHBsYXRmb3Jtcy4KKwlUaGUgcGF0Y2ggc2hv dWxkIGFsc28gZml4IHRoZSBsYXN0IHZlc3RpZ2VzIG9mIEJ1ZyM5NDg4LAorCWEgYnVnIHdo aWNoIGhhcyBtb3N0bHkgYmVlbiBmaXhlZCBvbiB0aGUgdHJ1bmsgYnkgb3RoZXIgY2hhbmdl cy4KKwkqIGNhbGxwcm9jLmMsIHByb2Nlc3MuaCAoc3luY2hfcHJvY2Vzc19hbGl2ZSwgc3lu Y2hfcHJvY2Vzc19kZWF0aCkKKwkoc3luY2hfcHJvY2Vzc190ZXJtc2lnLCBzeW5jX3Byb2Nl c3NfcmV0Y29kZSk6CisJUmVtb3ZlLiAgQWxsIHVzZXMgcmVtb3ZlZCwgdG8gc2ltcGxpZnkg YW5hbHlzaXMgYW5kIHNvIHRoYXQKKwlsZXNzIGNvbnNpbmcgaXMgZG9uZSBpbnNpZGUgY3Jp dGljYWwgc2VjdGlvbnMuCisJKiBjYWxscHJvYy5jIChjYWxsX3Byb2Nlc3NfZXhpdGVkKTog UmVtb3ZlLiAgQWxsIHVzZXMgcmVwbGFjZWQKKwl3aXRoICFzeW5jaF9wcm9jZXNzX3BpZC4K KwkqIGNhbGxwcm9jLmMgKHN5bmNoX3Byb2Nlc3NfcGlkLCBzeW5jaF9wcm9jZXNzX2ZkKTog TmV3IHN0YXRpYyB2YXJzLgorCVRoZXNlIHRha2UgdGhlIHJvbGUgb2Ygd2hhdCB1c2VkIHRv IGJlIGluIHVud2luZC1wcm90ZWN0IGFyZy4KKwlBbGwgdXNlcyBjaGFuZ2VkLgorCShibG9j a19jaGlsZF9zaWduYWwsIHVuYmxvY2tfY2hpbGRfc2lnbmFsKToKKwlOZXcgZnVuY3Rpb25z LCB0byBhdm9pZCByYWNlcyB0aGF0IGNvdWxkIGtpbGwgaW5ub2NlbnQtdmljdGltIHByb2Nl c3Nlcy4KKwkoY2FsbF9wcm9jZXNzX2tpbGwsIGNhbGxfcHJvY2Vzc19jbGVhbnVwLCBGY2Fs bF9wcm9jZXNzKTogVXNlIHRoZW0uCisJKGNhbGxfcHJvY2Vzc19raWxsKTogUmVjb3JkIGtp bGxlZCBwcm9jZXNzZXMgYXMgZGVsZXRlZCwgc28gdGhhdAorCXpvbWJpZXMgZG8gbm90IGNs dXR0ZXIgdXAgdGhlIHN5c3RlbS4gIERvIHRoaXMgaW5zaWRlIGEgY3JpdGljYWwKKwlzZWN0 aW9uLCB0byBhdm9pZCBhIHJhY2UgdGhhdCB3b3VsZCBhbGxvdyB0aGUgY2x1dHRlci4KKwko Y2FsbF9wcm9jZXNzX2NsZWFudXApOiBGaXggY29kZSBzbyB0aGF0IHRoZSBzZWNvbmQgQy1n IHdvcmtzIGFnYWluCisJb24gY29tbW9uIHBsYXRmb3JtcyBzdWNoIGFzIEdOVS9MaW51eC4K KwkoRmNhbGxfcHJvY2Vzcyk6IENyZWF0ZSB0aGUgY2hpbGQgcHJvY2VzcyBpbiBhIGNyaXRp Y2FsIHNlY3Rpb24sCisJdG8gZml4IGEgcmFjZSBjb25kaXRpb24uICBJZiBjcmVhdGluZyBh biBhc3luY2hyb25vdXMgcHJvY2VzcywKKwlyZWNvcmQgaXQgYXMgZGVsZXRlZCBzbyB0aGF0 IHpvbWJpZXMgZG8gbm90IGNsdXR0ZXIgdXAgdGhlIHN5c3RlbS4KKwlEbyB1bndpbmQtcHJv dGVjdCBmb3IgV0lORE9XU05UIHRvbywgYXMgdGhhdCdzIHNpbXBsZXIgaW4gdGhlCisJbGln aHQgb2YgdGhlc2UgY2hhbmdlcy4gIE9taXQgdW5uZWNlc3NhcnkgY2FsbCB0byBlbWFjc19j bG9zZQorCWJlZm9yZSBmYWlsdXJlLCBhcyB0aGUgdW53aW5kLXByb3RlY3QgY29kZSBkb2Vz IHRoYXQuCisJKiBjYWxscHJvYy5jIChjYWxsX3Byb2Nlc3NfY2xlYW51cCk6CisJKiB3MzJw cm9jLmMgKHdhaXRwaWQpOiBTaW1wbGlmeSBub3cgdGhhdCBzeW5jaF9wcm9jZXNzX2FsaXZl IGlzIGdvbmUuCisJKiBwcm9jZXNzLmMgKHJlY29yZF9kZWxldGVkX3BpZCk6IE5ldyBmdW5j dGlvbiwgY29udGFpbmluZworCWNvZGUgcmVmYWN0b3JlZCBvdXQgb2YgRmRlbGV0ZV9wcm9j ZXNzLgorCShGZGVsZXRlX3Byb2Nlc3MpOiBVc2UgaXQuCisJKHByb2Nlc3Nfc3RhdHVzX3Jl dHJpZXZlZCk6IFJlbW92ZS4gIEFsbCBjYWxsZXJzIGNoYW5nZWQgdG8gdXNlCisJY2hpbGRf c3RhdHVzX2NoYW5nZS4KKwkocmVjb3JkX2NoaWxkX3N0YXR1c19jaGFuZ2UpOiBSZW1vdmUs IGZvbGRpbmcgaXRzIGNvbnRlbnRzIGludG8gLi4uCisJKGhhbmRsZV9jaGlsZF9zaWduYWwp OiAuLi4gdGhpcyBzaWduYWwgaGFuZGxlci4gIE5vdywgdGhpcworCWZ1bmN0aW9uIGlzIHB1 cmVseSBhIGhhbmRsZXIgZm9yIFNJR0NITEQsIGFuZCBpcyBub3QgY2FsbGVkIGFmdGVyCisJ YSBzeW5jaHJvbm91cyB3YWl0cGlkIHJldHVybnM7IHRoZSBzeW5jaHJvbm91cyBjb2RlIGlz IG1vdmVkIHRvCisJd2FpdF9mb3JfdGVybWluYXRpb24uICBUaGVyZSBpcyBubyBuZWVkIHRv IHdvcnJ5IGFib3V0IHJlYXBpbmcKKwltb3JlIHRoYW4gb25lIGNoaWxkIG5vdy4KKwkqIHN5 c2RlcC5jIChnZXRfY2hpbGRfc3RhdHVzLCBjaGlsZF9zdGF0dXNfY2hhbmdlZCk6IE5ldyBm dW5jdGlvbnMuCisJKHdhaXRfZm9yX3Rlcm1pbmF0aW9uKTogTm93IHRha2VzIGludCAqIHN0 YXR1cyBhbmQgYm9vbAorCWludGVycnVwdGlibGUgYXJndW1lbnRzLCB0b28uICBEbyBub3Qg cmVjb3JkIGNoaWxkIHN0YXR1cyBjaGFuZ2U7CisJdGhhdCdzIG5vdyB0aGUgY2FsbGVyJ3Mg cmVzcG9uc2liaWxpdHkuICBBbGwgY2FsbGVycyBjaGFuZ2VkLgorCVJlaW1wbGVtZW50IGlu IHRlcm1zIG9mIGdldF9jaGlsZF9zdGF0dXMuCisJKHdhaXRfZm9yX3Rlcm1pbmF0aW9uXzEs IGludGVycnVwdGlibGVfd2FpdF9mb3JfdGVybWluYXRpb24pOgorCVJlbW92ZS4gIEFsbCBj YWxsZXJzIGNoYW5nZWQgdG8gdXNlIHdhaXRfZm9yX3Rlcm1pbmF0aW9uLgorCSogc3lzd2Fp dC5oOiBJbmNsdWRlIDxzdGRib29sLmg+LCBmb3IgYm9vbC4KKwkocmVjb3JkX2NoaWxkX3N0 YXR1c19jaGFuZ2UsIGludGVycnVwdGlibGVfd2FpdF9mb3JfdGVybWluYXRpb24pOgorCVJl bW92ZSBkZWNscy4KKwkocmVjb3JkX2RlbGV0ZWRfcGlkLCBjaGlsZF9zdGF0dXNfY2hhbmdl ZCk6IE5ldyBkZWNscy4KKwkod2FpdF9mb3JfdGVybWluYXRpb24pOiBBZGp1c3QgdG8gQVBJ IGNoYW5nZXMgbm90ZWQgYWJvdmUuCisKIAkqIGNhbGxwcm9jLmMgKEZjYWxsX3Byb2Nlc3Mp OiBEb24ndCBtaXNyZXBvcnQgdmZvcmsgZmFpbHVyZS4KIAogMjAxMi0xMS0yOCAgUGF1bCBF Z2dlcnQgIDxlZ2dlcnRAY3MudWNsYS5lZHU+Cgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL2Nh bGxwcm9jLmMnCi0tLSBzcmMvY2FsbHByb2MuYwkyMDEyLTExLTI5IDAwOjM2OjIyICswMDAw CisrKyBzcmMvY2FsbHByb2MuYwkyMDEyLTExLTI5IDAyOjI0OjQ1ICswMDAwCkBAIC02Nyw4 OCArNjcsMTEwIEBACiAvKiBQYXR0ZXJuIHVzZWQgYnkgY2FsbC1wcm9jZXNzLXJlZ2lvbiB0 byBtYWtlIHRlbXAgZmlsZXMuICAqLwogc3RhdGljIExpc3BfT2JqZWN0IFZ0ZW1wX2ZpbGVf bmFtZV9wYXR0ZXJuOwogCi0vKiBUcnVlIGlmIHdlIGFyZSBhYm91dCB0byBmb3JrIG9mZiBh IHN5bmNocm9ub3VzIHByb2Nlc3Mgb3IgaWYgd2UKLSAgIGFyZSB3YWl0aW5nIGZvciBpdC4g ICovCi1ib29sIHN5bmNoX3Byb2Nlc3NfYWxpdmU7Ci0KLS8qIE5vbnplcm8gPT4gdGhpcyBp cyBhIHN0cmluZyBleHBsYWluaW5nIGRlYXRoIG9mIHN5bmNocm9ub3VzIHN1YnByb2Nlc3Mu ICAqLwotY29uc3QgY2hhciAqc3luY2hfcHJvY2Vzc19kZWF0aDsKLQotLyogTm9uemVybyA9 PiB0aGlzIGlzIHRoZSBzaWduYWwgbnVtYmVyIHRoYXQgdGVybWluYXRlZCB0aGUgc3VicHJv Y2Vzcy4gICovCi1pbnQgc3luY2hfcHJvY2Vzc190ZXJtc2lnOwotCi0vKiBJZiBzeW5jaF9w cm9jZXNzX2RlYXRoIGlzIHplcm8sCi0gICB0aGlzIGlzIGV4aXQgY29kZSBvZiBzeW5jaHJv bm91cyBzdWJwcm9jZXNzLiAgKi8KLWludCBzeW5jaF9wcm9jZXNzX3JldGNvZGU7Ci0KKy8q IFRoZSBuZXh0IHR3byB2YXJpYWJsZXMgYXJlIHZhbGlkIG9ubHkgd2hpbGUgcmVjb3JkLXVu d2luZC1wcm90ZWN0CisgICBpcyBpbiBwbGFjZSBkdXJpbmcgY2FsbC1wcm9jZXNzIGZvciBh IHN5bmNocm9ub3VzIHN1YnByb2Nlc3MuICBBdAorICAgb3RoZXIgdGltZXMsIHRoZWlyIGNv bnRlbnRzIGFyZSBpcnJlbGV2YW50LiAgRG9pbmcgdGhpcyB2aWEgc3RhdGljCisgICBDIHZh cmlhYmxlcyBpcyBtb3JlIGNvbnZlbmllbnQgdGhhbiBwdXR0aW5nIHRoZW0gaW50byB0aGUg YXJndW1lbnRzCisgICBvZiByZWNvcmQtdW53aW5kLXByb3RlY3QsIGFzIHRoZXkgbmVlZCB0 byBiZSB1cGRhdGVkIGF0IHJhbmRvbWlzaAorICAgdGltZXMgaW4gdGhlIGNvZGUsIGFuZCBM aXNwIGNhbm5vdCBhbHdheXMgc3RvcmUgdGhlc2UgdmFsdWVzIGFzCisgICBFbWFjcyBpbnRl Z2Vycy4gIEl0J3Mgc2FmZSB0byB1c2Ugc3RhdGljIHZhcmlhYmxlcyBoZXJlLCBhcyB0aGUK KyAgIGNvZGUgaXMgbmV2ZXIgaW52b2tlZCByZWVudHJhbnRseS4gICovCisKKy8qIElmIG5v bnplcm8sIGEgcHJvY2Vzcy1JRCB0aGF0IGhhcyBub3QgYmVlbiByZWFwZWQuICAqLworc3Rh dGljIHBpZF90IHN5bmNoX3Byb2Nlc3NfcGlkOworCisvKiBJZiBub25uZWdhdGl2ZSwgYSBm aWxlIGRlc2NyaXB0b3IgdGhhdCBoYXMgbm90IGJlZW4gY2xvc2VkLiAgKi8KK3N0YXRpYyBp bnQgc3luY2hfcHJvY2Vzc19mZDsKIAwKKy8qIEJsb2NrIFNJR0NITEQuICAqLworCitzdGF0 aWMgdm9pZAorYmxvY2tfY2hpbGRfc2lnbmFsICh2b2lkKQoreworI2lmZGVmIFNJR0NITEQK KyAgc2lnc2V0X3QgYmxvY2tlZDsKKyAgc2lnZW1wdHlzZXQgKCZibG9ja2VkKTsKKyAgc2ln YWRkc2V0ICgmYmxvY2tlZCwgU0lHQ0hMRCk7CisgIHB0aHJlYWRfc2lnbWFzayAoU0lHX0JM T0NLLCAmYmxvY2tlZCwgMCk7CisjZW5kaWYKK30KKworLyogVW5ibG9jayBTSUdDSExELiAg Ki8KKworc3RhdGljIHZvaWQKK3VuYmxvY2tfY2hpbGRfc2lnbmFsICh2b2lkKQoreworI2lm ZGVmIFNJR0NITEQKKyAgcHRocmVhZF9zaWdtYXNrIChTSUdfU0VUTUFTSywgJmVtcHR5X21h c2ssIDApOworI2VuZGlmCit9CisKKy8qIENsZWFuIHVwIHdoZW4gZXhpdGluZyBjYWxsX3By b2Nlc3NfY2xlYW51cC4gICovCisKK3N0YXRpYyBMaXNwX09iamVjdAorY2FsbF9wcm9jZXNz X2tpbGwgKExpc3BfT2JqZWN0IGlnbm9yZWQpCit7CisgIGlmICgwIDw9IHN5bmNoX3Byb2Nl c3NfZmQpCisgICAgZW1hY3NfY2xvc2UgKHN5bmNoX3Byb2Nlc3NfZmQpOworCisgIC8qIElm IFBJRCBpcyByZWFwYWJsZSwga2lsbCBpdCBhbmQgcmVjb3JkIGl0IGFzIGEgZGVsZXRlZCBw cm9jZXNzLgorICAgICBEbyB0aGlzIGluIGEgY3JpdGljYWwgc2VjdGlvbi4gIFVubGVzcyBQ SUQgaXMgd2VkZ2VkIGl0IHdpbGwgYmUKKyAgICAgcmVhcGVkIG9uIHJlY2VpcHQgb2YgdGhl IGZpcnN0IFNJR0NITEQgYWZ0ZXIgdGhlIGNyaXRpY2FsIHNlY3Rpb24uICAqLworICBpZiAo c3luY2hfcHJvY2Vzc19waWQpCisgICAgeworICAgICAgYmxvY2tfY2hpbGRfc2lnbmFsICgp OworICAgICAgcmVjb3JkX2RlbGV0ZWRfcGlkIChzeW5jaF9wcm9jZXNzX3BpZCk7CisgICAg ICBFTUFDU19LSUxMUEcgKHN5bmNoX3Byb2Nlc3NfcGlkLCBTSUdLSUxMKTsKKyAgICAgIHVu YmxvY2tfY2hpbGRfc2lnbmFsICgpOworICAgIH0KKworICByZXR1cm4gUW5pbDsKK30KKwog LyogQ2xlYW4gdXAgd2hlbiBleGl0aW5nIEZjYWxsX3Byb2Nlc3MuCiAgICBPbiBNU0RPUywg ZGVsZXRlIHRoZSB0ZW1wb3JhcnkgZmlsZSBvbiBhbnkga2luZCBvZiB0ZXJtaW5hdGlvbi4K ICAgIE9uIFVuaXgsIGtpbGwgdGhlIHByb2Nlc3MgYW5kIGFueSBjaGlsZHJlbiBvbiB0ZXJt aW5hdGlvbiBieSBzaWduYWwuICAqLwogCi0vKiBUcnVlIGlmIHRoaXMgaXMgdGVybWluYXRp b24gZHVlIHRvIGV4aXQuICAqLwotc3RhdGljIGJvb2wgY2FsbF9wcm9jZXNzX2V4aXRlZDsK LQotc3RhdGljIExpc3BfT2JqZWN0Ci1jYWxsX3Byb2Nlc3Nfa2lsbCAoTGlzcF9PYmplY3Qg ZmRwaWQpCi17Ci0gIGludCBmZDsKLSAgcGlkX3QgcGlkOwotICBDT05TX1RPX0lOVEVHRVIg KEZjYXIgKGZkcGlkKSwgaW50LCBmZCk7Ci0gIENPTlNfVE9fSU5URUdFUiAoRmNkciAoZmRw aWQpLCBwaWRfdCwgcGlkKTsKLSAgZW1hY3NfY2xvc2UgKGZkKTsKLSAgRU1BQ1NfS0lMTFBH IChwaWQsIFNJR0tJTEwpOwotICBzeW5jaF9wcm9jZXNzX2FsaXZlID0gMDsKLSAgcmV0dXJu IFFuaWw7Ci19Ci0KIHN0YXRpYyBMaXNwX09iamVjdAogY2FsbF9wcm9jZXNzX2NsZWFudXAg KExpc3BfT2JqZWN0IGFyZykKIHsKLSAgTGlzcF9PYmplY3QgZmRwaWQgPSBGY2RyIChhcmcp OwotICBpbnQgZmQ7Ci0jaWYgZGVmaW5lZCAoTVNET1MpCi0gIExpc3BfT2JqZWN0IGZpbGU7 CisjaWZkZWYgTVNET1MKKyAgTGlzcF9PYmplY3QgYnVmZmVyID0gRmNhciAoYXJnKTsKKyAg TGlzcF9PYmplY3QgZmlsZSA9IEZjZHIgKGFyZyk7CiAjZWxzZQotICBwaWRfdCBwaWQ7Cisg IExpc3BfT2JqZWN0IGJ1ZmZlciA9IGFyZzsKICNlbmRpZgogCi0gIEZzZXRfYnVmZmVyIChG Y2FyIChhcmcpKTsKLSAgQ09OU19UT19JTlRFR0VSIChGY2FyIChmZHBpZCksIGludCwgZmQp OwotCi0jaWYgZGVmaW5lZCAoTVNET1MpCi0gIC8qIGZvciBNU0RPUyBmZHBpZCBpcyByZWFs bHkgKGZkIC4gdGVtcGZpbGUpICAqLwotICBmaWxlID0gRmNkciAoZmRwaWQpOwotICAvKiBG RCBpcyAtMSBhbmQgRklMRSBpcyAiIiB3aGVuIHdlIGRpZG4ndCBhY3R1YWxseSBjcmVhdGUg YQotICAgICB0ZW1wb3JhcnkgZmlsZSBpbiBjYWxsLXByb2Nlc3MuICAqLwotICBpZiAoZmQg Pj0gMCkKLSAgICBlbWFjc19jbG9zZSAoZmQpOwotICBpZiAoIShzdHJjbXAgKFNEQVRBIChm aWxlKSwgTlVMTF9ERVZJQ0UpID09IDAgfHwgU1JFRiAoZmlsZSwgMCkgPT0gJ1wwJykpCi0g ICAgdW5saW5rIChTREFUQSAoZmlsZSkpOwotI2Vsc2UgLyogbm90IE1TRE9TICovCi0gIENP TlNfVE9fSU5URUdFUiAoRmNkciAoZmRwaWQpLCBwaWRfdCwgcGlkKTsKLQotICBpZiAoY2Fs bF9wcm9jZXNzX2V4aXRlZCkKLSAgICB7Ci0gICAgICBlbWFjc19jbG9zZSAoZmQpOwotICAg ICAgcmV0dXJuIFFuaWw7Ci0gICAgfQotCi0gIGlmIChFTUFDU19LSUxMUEcgKHBpZCwgU0lH SU5UKSA9PSAwKQorICBGc2V0X2J1ZmZlciAoYnVmZmVyKTsKKworI2lmbmRlZiBNU0RPUwor ICAvKiBJZiB0aGUgcHJvY2VzcyBzdGlsbCBleGlzdHMsIGtpbGwgaXRzIHByb2Nlc3MgZ3Jv dXAuICAqLworICBpZiAoc3luY2hfcHJvY2Vzc19waWQpCiAgICAgewogICAgICAgcHRyZGlm Zl90IGNvdW50ID0gU1BFQ1BETF9JTkRFWCAoKTsKLSAgICAgIHJlY29yZF91bndpbmRfcHJv dGVjdCAoY2FsbF9wcm9jZXNzX2tpbGwsIGZkcGlkKTsKKyAgICAgIEVNQUNTX0tJTExQRyAo c3luY2hfcHJvY2Vzc19waWQsIFNJR0lOVCk7CisgICAgICByZWNvcmRfdW53aW5kX3Byb3Rl Y3QgKGNhbGxfcHJvY2Vzc19raWxsLCBtYWtlX251bWJlciAoMCkpOwogICAgICAgbWVzc2Fn ZTEgKCJXYWl0aW5nIGZvciBwcm9jZXNzIHRvIGRpZS4uLih0eXBlIEMtZyBhZ2FpbiB0byBr aWxsIGl0IGluc3RhbnRseSkiKTsKICAgICAgIGltbWVkaWF0ZV9xdWl0ID0gMTsKICAgICAg IFFVSVQ7Ci0gICAgICB3YWl0X2Zvcl90ZXJtaW5hdGlvbiAocGlkKTsKKyAgICAgIHdhaXRf Zm9yX3Rlcm1pbmF0aW9uIChzeW5jaF9wcm9jZXNzX3BpZCwgMCwgMSk7CisgICAgICBzeW5j aF9wcm9jZXNzX3BpZCA9IDA7CiAgICAgICBpbW1lZGlhdGVfcXVpdCA9IDA7CiAgICAgICBz cGVjcGRsX3B0ciA9IHNwZWNwZGwgKyBjb3VudDsgLyogRGlzY2FyZCB0aGUgdW53aW5kIHBy b3RlY3QuICAqLwogICAgICAgbWVzc2FnZTEgKCJXYWl0aW5nIGZvciBwcm9jZXNzIHRvIGRp ZS4uLmRvbmUiKTsKICAgICB9Ci0gIHN5bmNoX3Byb2Nlc3NfYWxpdmUgPSAwOwotICBlbWFj c19jbG9zZSAoZmQpOwotI2VuZGlmIC8qIG5vdCBNU0RPUyAqLworI2VuZGlmCisKKyAgaWYg KDAgPD0gc3luY2hfcHJvY2Vzc19mZCkKKyAgICBlbWFjc19jbG9zZSAoc3luY2hfcHJvY2Vz c19mZCk7CisKKyNpZmRlZiBNU0RPUworICAvKiBGSUxFIGlzICIiIHdoZW4gd2UgZGlkbid0 IGFjdHVhbGx5IGNyZWF0ZSBhIHRlbXBvcmFyeSBmaWxlIGluCisgICAgIGNhbGwtcHJvY2Vz cy4gICovCisgIGlmICghKHN0cmNtcCAoU0RBVEEgKGZpbGUpLCBOVUxMX0RFVklDRSkgPT0g MCB8fCBTUkVGIChmaWxlLCAwKSA9PSAnXDAnKSkKKyAgICB1bmxpbmsgKFNEQVRBIChmaWxl KSk7CisjZW5kaWYKKwogICByZXR1cm4gUW5pbDsKIH0KIApAQCAtMTgxLDkgKzIwMywxMCBA QAogdXNhZ2U6IChjYWxsLXByb2Nlc3MgUFJPR1JBTSAmb3B0aW9uYWwgSU5GSUxFIEJVRkZF UiBESVNQTEFZICZyZXN0IEFSR1MpICAqLykKICAgKHB0cmRpZmZfdCBuYXJncywgTGlzcF9P YmplY3QgKmFyZ3MpCiB7Ci0gIExpc3BfT2JqZWN0IGluZmlsZSwgYnVmZmVyLCBjdXJyZW50 X2RpciwgcGF0aCwgY2xlYW51cF9pbmZvX3RhaWw7CisgIExpc3BfT2JqZWN0IGluZmlsZSwg YnVmZmVyLCBjdXJyZW50X2RpciwgcGF0aDsKICAgYm9vbCBkaXNwbGF5X3A7CiAgIGludCBm ZDAsIGZkMSwgZmlsZWZkOworICBpbnQgc3RhdHVzOwogICBwdHJkaWZmX3QgY291bnQgPSBT UEVDUERMX0lOREVYICgpOwogICBVU0VfU0FGRV9BTExPQ0E7CiAKQEAgLTE5OSw3ICsyMjIs NyBAQAogI2Vsc2UKICAgcGlkX3QgcGlkOwogI2VuZGlmCi0gIGludCB2Zm9ya19lcnJubzsK KyAgaW50IGNoaWxkX2Vycm5vOwogICBpbnQgZmRfb3V0cHV0ID0gLTE7CiAgIHN0cnVjdCBj b2Rpbmdfc3lzdGVtIHByb2Nlc3NfY29kaW5nOyAvKiBjb2Rpbmctc3lzdGVtIG9mIHByb2Nl c3Mgb3V0cHV0ICovCiAgIHN0cnVjdCBjb2Rpbmdfc3lzdGVtIGFyZ3VtZW50X2NvZGluZzsJ LyogY29kaW5nLXN5c3RlbSBvZiBhcmd1bWVudHMgKi8KQEAgLTQ5NiwxNiArNTE5LDYgQEAK ICAgICBpZiAoZmRfb3V0cHV0ID49IDApCiAgICAgICBmZDEgPSBmZF9vdXRwdXQ7CiAKLSAg ICAvKiBSZWNvcmQgdGhhdCB3ZSdyZSBhYm91dCB0byBjcmVhdGUgYSBzeW5jaHJvbm91cyBw cm9jZXNzLiAgKi8KLSAgICBzeW5jaF9wcm9jZXNzX2FsaXZlID0gMTsKLQotICAgIC8qIFRo ZXNlIHZhcnMgcmVjb3JkIGluZm9ybWF0aW9uIGZyb20gcHJvY2VzcyB0ZXJtaW5hdGlvbi4K LSAgICAgICBDbGVhciB0aGVtIG5vdyBiZWZvcmUgcHJvY2VzcyBjYW4gcG9zc2libHkgdGVy bWluYXRlLAotICAgICAgIHRvIGF2b2lkIHRpbWluZyBlcnJvciBpZiBwcm9jZXNzIHRlcm1p bmF0ZXMgc29vbi4gICovCi0gICAgc3luY2hfcHJvY2Vzc19kZWF0aCA9IDA7Ci0gICAgc3lu Y2hfcHJvY2Vzc19yZXRjb2RlID0gMDsKLSAgICBzeW5jaF9wcm9jZXNzX3Rlcm1zaWcgPSAw OwotCiAgICAgaWYgKE5JTFAgKGVycm9yX2ZpbGUpKQogICAgICAgZmRfZXJyb3IgPSBlbWFj c19vcGVuIChOVUxMX0RFVklDRSwgT19XUk9OTFksIDApOwogICAgIGVsc2UgaWYgKFNUUklO R1AgKGVycm9yX2ZpbGUpKQpAQCAtNTM4LDIzICs1NTEsMjEgQEAKIAogI2lmZGVmIE1TRE9T IC8qIE1XLCBKdWx5IDE5OTMgKi8KICAgICAvKiBOb3RlIHRoYXQgb24gTVNET1MgYGNoaWxk X3NldHVwJyBhY3R1YWxseSByZXR1cm5zIHRoZSBjaGlsZCBwcm9jZXNzCi0gICAgICAgZXhp dCBzdGF0dXMsIG5vdCBpdHMgUElELCBzbyB3ZSBhc3NpZ24gaXQgdG8gYHN5bmNoX3Byb2Nl c3NfcmV0Y29kZScKLSAgICAgICBiZWxvdy4gICovCisgICAgICAgZXhpdCBzdGF0dXMsIG5v dCBpdHMgUElELCBzbyBhc3NpZ24gaXQgdG8gc3RhdHVzIGJlbG93LiAgKi8KICAgICBwaWQg PSBjaGlsZF9zZXR1cCAoZmlsZWZkLCBvdXRmaWxlZmQsIGZkX2Vycm9yLCBuZXdfYXJndiwg MCwgY3VycmVudF9kaXIpOwotCi0gICAgLyogUmVjb3JkIHRoYXQgdGhlIHN5bmNocm9ub3Vz IHByb2Nlc3MgZXhpdGVkIGFuZCBub3RlIGl0cwotICAgICAgIHRlcm1pbmF0aW9uIHN0YXR1 cy4gICovCi0gICAgc3luY2hfcHJvY2Vzc19hbGl2ZSA9IDA7Ci0gICAgc3luY2hfcHJvY2Vz c19yZXRjb2RlID0gcGlkOwotICAgIGlmIChzeW5jaF9wcm9jZXNzX3JldGNvZGUgPCAwKSAg LyogbWVhbnMgaXQgY291bGRuJ3QgYmUgZXhlYydlZCAqLwotICAgICAgewotCXN5bmNocm9u aXplX3N5c3RlbV9tZXNzYWdlc19sb2NhbGUgKCk7Ci0Jc3luY2hfcHJvY2Vzc19kZWF0aCA9 IHN0cmVycm9yIChlcnJubyk7Ci0gICAgICB9CisgICAgY2hpbGRfZXJybm8gPSBlcnJubzsK IAogICAgIGVtYWNzX2Nsb3NlIChvdXRmaWxlZmQpOwogICAgIGlmIChmZF9lcnJvciAhPSBv dXRmaWxlZmQpCiAgICAgICBlbWFjc19jbG9zZSAoZmRfZXJyb3IpOworICAgIGlmIChwaWQg PCAwKQorICAgICAgeworCXN5bmNocm9uaXplX3N5c3RlbV9tZXNzYWdlc19sb2NhbGUgKCk7 CisJcmV0dXJuCisJICBjb2RlX2NvbnZlcnRfc3RyaW5nX25vcmVjb3JkIChidWlsZF9zdHJp bmcgKHN0cmVycm9yIChjaGlsZF9lcnJubykpLAorCQkJCQlWbG9jYWxlX2NvZGluZ19zeXN0 ZW0sIDApOworICAgICAgfQorICAgIHN0YXR1cyA9IHBpZDsKICAgICBmZDEgPSAtMTsgLyog Tm8gaGFybSBpbiBjbG9zaW5nIHRoYXQgb25lISAgKi8KICAgICBpZiAodGVtcGZpbGUpCiAg ICAgICB7CkBAIC01NzIsMTIgKzU4MywyMSBAQAogICAgIGVsc2UKICAgICAgIGZkMCA9IC0x OyAvKiBXZSBhcmUgbm90IGdvaW5nIHRvIHJlYWQgZnJvbSB0ZW1wZmlsZS4gICAqLwogI2Vs c2UgLyogbm90IE1TRE9TICovCisKKyAgICAvKiBEbyB0aGUgdW53aW5kLXByb3RlY3Qgbm93 LCBldmVuIHRob3VnaCB0aGUgcGlkIGlzIG5vdCBrbm93biwgc28KKyAgICAgICB0aGF0IG5v IHN0b3JhZ2UgYWxsb2NhdGlvbiBpcyBkb25lIGluIHRoZSBjcml0aWNhbCBzZWN0aW9uLgor ICAgICAgIFRoZSBhY3R1YWwgUElEIHdpbGwgYmUgZmlsbGVkIGluIGR1cmluZyB0aGUgY3Jp dGljYWwgc2VjdGlvbi4gICovCisgICAgc3luY2hfcHJvY2Vzc19waWQgPSAwOworICAgIHN5 bmNoX3Byb2Nlc3NfZmQgPSBmZDA7CisgICAgcmVjb3JkX3Vud2luZF9wcm90ZWN0IChjYWxs X3Byb2Nlc3NfY2xlYW51cCwgRmN1cnJlbnRfYnVmZmVyICgpKTsKKworICAgIGJsb2NrX2lu cHV0ICgpOworICAgIGJsb2NrX2NoaWxkX3NpZ25hbCAoKTsKKwogI2lmZGVmIFdJTkRPV1NO VAogICAgIHBpZCA9IGNoaWxkX3NldHVwIChmaWxlZmQsIGZkMSwgZmRfZXJyb3IsIG5ld19h cmd2LCAwLCBjdXJyZW50X2Rpcik7CiAjZWxzZSAgLyogbm90IFdJTkRPV1NOVCAqLwogCi0g ICAgYmxvY2tfaW5wdXQgKCk7Ci0KICAgICAvKiB2Zm9yaywgYW5kIHByZXZlbnQgbG9jYWwg dmFycyBmcm9tIGJlaW5nIGNsb2JiZXJlZCBieSB0aGUgdmZvcmsuICAqLwogICAgIHsKICAg ICAgIExpc3BfT2JqZWN0IHZvbGF0aWxlIGJ1ZmZlcl92b2xhdGlsZSA9IGJ1ZmZlcjsKQEAg LTU5Nyw2ICs2MTcsNyBAQAogICAgICAgY2hhciAqKnZvbGF0aWxlIG5ld19zYXZlX2Vudmly b24gPSBzYXZlX2Vudmlyb247CiAKICAgICAgIHBpZCA9IHZmb3JrICgpOworICAgICAgY2hp bGRfZXJybm8gPSBlcnJubzsKIAogICAgICAgYnVmZmVyID0gYnVmZmVyX3ZvbGF0aWxlOwog ICAgICAgY29kaW5nX3N5c3RlbXMgPSBjb2Rpbmdfc3lzdGVtc192b2xhdGlsZTsKQEAgLTYx Nyw2ICs2MzgsOCBAQAogCiAgICAgaWYgKHBpZCA9PSAwKQogICAgICAgeworCXVuYmxvY2tf Y2hpbGRfc2lnbmFsICgpOworCiAJaWYgKGZkMCA+PSAwKQogCSAgZW1hY3NfY2xvc2UgKGZk MCk7CiAKQEAgLTYyOCwxMSArNjUxLDIxIEBACiAJY2hpbGRfc2V0dXAgKGZpbGVmZCwgZmQx LCBmZF9lcnJvciwgbmV3X2FyZ3YsIDAsIGN1cnJlbnRfZGlyKTsKICAgICAgIH0KIAotICAg IHZmb3JrX2Vycm5vID0gZXJybm87CisjZW5kaWYgLyogbm90IFdJTkRPV1NOVCAqLworCisg ICAgY2hpbGRfZXJybm8gPSBlcnJubzsKKworICAgIGlmICgwIDwgcGlkKQorICAgICAgewor CWlmIChJTlRFR0VSUCAoYnVmZmVyKSkKKwkgIHJlY29yZF9kZWxldGVkX3BpZCAocGlkKTsK KwllbHNlCisJICBzeW5jaF9wcm9jZXNzX3BpZCA9IHBpZDsKKyAgICAgIH0KKworICAgIHVu YmxvY2tfY2hpbGRfc2lnbmFsICgpOwogICAgIHVuYmxvY2tfaW5wdXQgKCk7CiAKLSNlbmRp ZiAvKiBub3QgV0lORE9XU05UICovCi0KICAgICAvKiBUaGUgTVNET1MgY2FzZSBkaWQgdGhp cyBhbHJlYWR5LiAgKi8KICAgICBpZiAoZmRfZXJyb3IgPj0gMCkKICAgICAgIGVtYWNzX2Ns b3NlIChmZF9lcnJvcik7CkBAIC02NTEsOSArNjg0LDcgQEAKIAogICBpZiAocGlkIDwgMCkK ICAgICB7Ci0gICAgICBpZiAoZmQwID49IDApCi0JZW1hY3NfY2xvc2UgKGZkMCk7Ci0gICAg ICBlcnJubyA9IHZmb3JrX2Vycm5vOworICAgICAgZXJybm8gPSBjaGlsZF9lcnJubzsKICAg ICAgIHJlcG9ydF9maWxlX2Vycm9yICgiRG9pbmcgdmZvcmsiLCBRbmlsKTsKICAgICB9CiAK QEAgLTY2NCwxOSArNjk1LDEyIEBACiAgICAgICByZXR1cm4gUW5pbDsKICAgICB9CiAKLSAg LyogRW5hYmxlIHNlbmRpbmcgc2lnbmFsIGlmIHVzZXIgcXVpdHMgYmVsb3cuICAqLwotICBj YWxsX3Byb2Nlc3NfZXhpdGVkID0gMDsKLQogI2lmIGRlZmluZWQgKE1TRE9TKQogICAvKiBN U0RPUyBuZWVkcyBkaWZmZXJlbnQgY2xlYW51cCBpbmZvcm1hdGlvbi4gICovCi0gIGNsZWFu dXBfaW5mb190YWlsID0gYnVpbGRfc3RyaW5nICh0ZW1wZmlsZSA/IHRlbXBmaWxlIDogIiIp OwotI2Vsc2UKLSAgY2xlYW51cF9pbmZvX3RhaWwgPSBJTlRFR0VSX1RPX0NPTlMgKHBpZCk7 Ci0jZW5kaWYgLyogbm90IE1TRE9TICovCiAgIHJlY29yZF91bndpbmRfcHJvdGVjdCAoY2Fs bF9wcm9jZXNzX2NsZWFudXAsCiAJCQkgRmNvbnMgKEZjdXJyZW50X2J1ZmZlciAoKSwKLQkJ CQlGY29ucyAoSU5URUdFUl9UT19DT05TIChmZDApLAotCQkJCSAgICAgICBjbGVhbnVwX2lu Zm9fdGFpbCkpKTsKKwkJCQlidWlsZF9zdHJpbmcgKHRlbXBmaWxlID8gdGVtcGZpbGUgOiAi IikpKTsKKyNlbmRpZgogCiAgIGlmIChCVUZGRVJQIChidWZmZXIpKQogICAgIEZzZXRfYnVm ZmVyIChidWZmZXIpOwpAQCAtODYzLDM4ICs4ODcsMzQgQEAKIAogI2lmbmRlZiBNU0RPUwog ICAvKiBXYWl0IGZvciBpdCB0byB0ZXJtaW5hdGUsIHVubGVzcyBpdCBhbHJlYWR5IGhhcy4g ICovCi0gIGlmIChvdXRwdXRfdG9fYnVmZmVyKQotICAgIHdhaXRfZm9yX3Rlcm1pbmF0aW9u IChwaWQpOwotICBlbHNlCi0gICAgaW50ZXJydXB0aWJsZV93YWl0X2Zvcl90ZXJtaW5hdGlv biAocGlkKTsKKyAgd2FpdF9mb3JfdGVybWluYXRpb24gKHBpZCwgJnN0YXR1cywgIW91dHB1 dF90b19idWZmZXIpOwogI2VuZGlmCiAKICAgaW1tZWRpYXRlX3F1aXQgPSAwOwogCiAgIC8q IERvbid0IGtpbGwgYW55IGNoaWxkcmVuIHRoYXQgdGhlIHN1YnByb2Nlc3MgbWF5IGhhdmUg bGVmdCBiZWhpbmQKICAgICAgd2hlbiBleGl0aW5nLiAgKi8KLSAgY2FsbF9wcm9jZXNzX2V4 aXRlZCA9IDE7CisgIHN5bmNoX3Byb2Nlc3NfcGlkID0gMDsKIAogICBTQUZFX0ZSRUUgKCk7 CiAgIHVuYmluZF90byAoY291bnQsIFFuaWwpOwogCi0gIGlmIChzeW5jaF9wcm9jZXNzX3Rl cm1zaWcpCisgIGlmIChXSUZTSUdOQUxFRCAoc3RhdHVzKSkKICAgICB7CiAgICAgICBjb25z dCBjaGFyICpzaWduYW1lOwogCiAgICAgICBzeW5jaHJvbml6ZV9zeXN0ZW1fbWVzc2FnZXNf bG9jYWxlICgpOwotICAgICAgc2lnbmFtZSA9IHN0cnNpZ25hbCAoc3luY2hfcHJvY2Vzc190 ZXJtc2lnKTsKKyAgICAgIHNpZ25hbWUgPSBzdHJzaWduYWwgKFdURVJNU0lHIChzdGF0dXMp KTsKIAogICAgICAgaWYgKHNpZ25hbWUgPT0gMCkKIAlzaWduYW1lID0gInVua25vd24iOwog Ci0gICAgICBzeW5jaF9wcm9jZXNzX2RlYXRoID0gc2lnbmFtZTsKKyAgICAgIHJldHVybiBj b2RlX2NvbnZlcnRfc3RyaW5nX25vcmVjb3JkIChidWlsZF9zdHJpbmcgKHNpZ25hbWUpLAor CQkJCQkgICBWbG9jYWxlX2NvZGluZ19zeXN0ZW0sIDApOwogICAgIH0KIAotICBpZiAoc3lu Y2hfcHJvY2Vzc19kZWF0aCkKLSAgICByZXR1cm4gY29kZV9jb252ZXJ0X3N0cmluZ19ub3Jl Y29yZCAoYnVpbGRfc3RyaW5nIChzeW5jaF9wcm9jZXNzX2RlYXRoKSwKLQkJCQkJIFZsb2Nh bGVfY29kaW5nX3N5c3RlbSwgMCk7Ci0gIHJldHVybiBtYWtlX251bWJlciAoc3luY2hfcHJv Y2Vzc19yZXRjb2RlKTsKKyAgZWFzc2VydCAoV0lGRVhJVEVEIChzdGF0dXMpKTsKKyAgcmV0 dXJuIG1ha2VfbnVtYmVyIChXRVhJVFNUQVRVUyAoc3RhdHVzKSk7CiB9CiAMCiBzdGF0aWMg TGlzcF9PYmplY3QKCj09PSBtb2RpZmllZCBmaWxlICdzcmMvcHJvY2Vzcy5jJwotLS0gc3Jj L3Byb2Nlc3MuYwkyMDEyLTExLTI3IDA1OjE3OjA3ICswMDAwCisrKyBzcmMvcHJvY2Vzcy5j CTIwMTItMTEtMjkgMDI6MjQ6NDUgKzAwMDAKQEAgLTc3NywxMCArNzc3LDIzIEBACiAvKiBG ZGVsZXRlX3Byb2Nlc3MgcHJvbWlzZXMgdG8gaW1tZWRpYXRlbHkgZm9yZ2V0IGFib3V0IHRo ZSBwcm9jZXNzLCBidXQgaW4KICAgIHJlYWxpdHksIEVtYWNzIG5lZWRzIHRvIHJlbWVtYmVy IHRob3NlIHByb2Nlc3NlcyB1bnRpbCB0aGV5IGhhdmUgYmVlbgogICAgdHJlYXRlZCBieSB0 aGUgU0lHQ0hMRCBoYW5kbGVyIGFuZCB3YWl0cGlkIGhhcyBiZWVuIGludm9rZWQgb24gdGhl bTsKLSAgIG90aGVyd2lzZSB0aGV5IG1pZ2h0IGZpbGwgdXAgdGhlIGtlcm5lbCdzIHByb2Nl c3MgdGFibGUuICAqLworICAgb3RoZXJ3aXNlIHRoZXkgbWlnaHQgZmlsbCB1cCB0aGUga2Vy bmVsJ3MgcHJvY2VzcyB0YWJsZS4KKworICAgU29tZSBwcm9jZXNzZXMgY3JlYXRlZCBieSBj YWxsLXByb2Nlc3MgYXJlIGFsc28gcHV0IG9udG8gdGhpcyBsaXN0LiAgKi8KIHN0YXRpYyBM aXNwX09iamVjdCBkZWxldGVkX3BpZF9saXN0OwogI2VuZGlmCiAKK3ZvaWQKK3JlY29yZF9k ZWxldGVkX3BpZCAocGlkX3QgcGlkKQoreworI2lmZGVmIFNJR0NITEQKKyAgZGVsZXRlZF9w aWRfbGlzdCA9IEZjb25zIChtYWtlX2ZpeG51bV9vcl9mbG9hdCAocGlkKSwKKwkJCSAgICAv KiBHQyB0cmVhdGVkIGVsZW1lbnRzIHNldCB0byBuaWwuICAqLworCQkJICAgIEZkZWxxIChR bmlsLCBkZWxldGVkX3BpZF9saXN0KSk7CisKKyNlbmRpZgorfQorCiBERUZVTiAoImRlbGV0 ZS1wcm9jZXNzIiwgRmRlbGV0ZV9wcm9jZXNzLCBTZGVsZXRlX3Byb2Nlc3MsIDEsIDEsIDAs CiAgICAgICAgZG9jOiAvKiBEZWxldGUgUFJPQ0VTUzoga2lsbCBpdCBhbmQgZm9yZ2V0IGFi b3V0IGl0IGltbWVkaWF0ZWx5LgogUFJPQ0VTUyBtYXkgYmUgYSBwcm9jZXNzLCBhIGJ1ZmZl ciwgdGhlIG5hbWUgb2YgYSBwcm9jZXNzIG9yIGJ1ZmZlciwgb3IKQEAgLTgwNyw5ICs4MjAs NyBAQAogICAgICAgcGlkX3QgcGlkID0gcC0+cGlkOwogCiAgICAgICAvKiBObyBwcm9ibGVt IHN0b3JpbmcgdGhlIHBpZCBoZXJlLCBhcyBpdCBpcyBzdGlsbCBpbiBWcHJvY2Vzc19hbGlz dC4gICovCi0gICAgICBkZWxldGVkX3BpZF9saXN0ID0gRmNvbnMgKG1ha2VfZml4bnVtX29y X2Zsb2F0IChwaWQpLAotCQkJCS8qIEdDIHRyZWF0ZWQgZWxlbWVudHMgc2V0IHRvIG5pbC4g ICovCi0JCQkJRmRlbHEgKFFuaWwsIGRlbGV0ZWRfcGlkX2xpc3QpKTsKKyAgICAgIHJlY29y ZF9kZWxldGVkX3BpZCAocGlkKTsKICAgICAgIC8qIElmIHRoZSBwcm9jZXNzIGhhcyBhbHJl YWR5IHNpZ25hbGVkLCByZW1vdmUgaXQgZnJvbSB0aGUgbGlzdC4gICovCiAgICAgICBpZiAo cC0+cmF3X3N0YXR1c19uZXcpCiAJdXBkYXRlX3N0YXR1cyAocCk7CkBAIC02MTYwLDM1ICs2 MTcxLDM3IEBACiAgIHJldHVybiBwcm9jZXNzOwogfQogDAotLyogSWYgdGhlIHN0YXR1cyBv ZiB0aGUgcHJvY2VzcyBERVNJUkVEIGhhcyBjaGFuZ2VkLCByZXR1cm4gdHJ1ZSBhbmQKLSAg IHNldCAqU1RBVFVTIHRvIGl0cyBleGl0IHN0YXR1czsgb3RoZXJ3aXNlLCByZXR1cm4gZmFs c2UuCi0gICBJZiBIQVZFIGlzIG5vbm5lZ2F0aXZlLCBhc3N1bWUgdGhhdCBIQVZFID0gd2Fp dHBpZCAoSEFWRSwgU1RBVFVTLCAuLi4pCi0gICBoYXMgYWxyZWFkeSBiZWVuIGludm9rZWQs IGFuZCBkbyBub3QgaW52b2tlIHdhaXRwaWQgYWdhaW4uICAqLwotCi1zdGF0aWMgYm9vbAot cHJvY2Vzc19zdGF0dXNfcmV0cmlldmVkIChwaWRfdCBkZXNpcmVkLCBwaWRfdCBoYXZlLCBp bnQgKnN0YXR1cykKLXsKLSAgaWYgKGhhdmUgPCAwKQotICAgIHsKLSAgICAgIC8qIEludm9r ZSB3YWl0cGlkIG9ubHkgd2l0aCBhIGtub3duIHByb2Nlc3MgSUQ7IGRvIG5vdCBpbnZva2UK LQkgd2FpdHBpZCB3aXRoIGEgbm9ucG9zaXRpdmUgYXJndW1lbnQuICBPdGhlcndpc2UsIEVt YWNzIG1pZ2h0Ci0JIHJlYXAgYW4gdW53YW50ZWQgcHJvY2VzcyBieSBtaXN0YWtlLiAgRm9y IGV4YW1wbGUsIGludm9raW5nCi0JIHdhaXRwaWQgKC0xLCAuLi4pIGNhbiBtZXNzIHVwIGds aWIgYnkgcmVhcGluZyBnbGliJ3Mgc3VicHJvY2Vzc2VzLAotCSBzbyB0aGF0IGFub3RoZXIg dGhyZWFkIHJ1bm5pbmcgZ2xpYiB3b24ndCBmaW5kIHRoZW0uICAqLwotICAgICAgZG8KLQlo YXZlID0gd2FpdHBpZCAoZGVzaXJlZCwgc3RhdHVzLCBXTk9IQU5HIHwgV1VOVFJBQ0VEKTsK LSAgICAgIHdoaWxlIChoYXZlIDwgMCAmJiBlcnJubyA9PSBFSU5UUik7Ci0gICAgfQotCi0g IHJldHVybiBoYXZlID09IGRlc2lyZWQ7Ci19Ci0KLS8qIElmIFBJRCBpcyBub25uZWdhdGl2 ZSwgdGhlIGNoaWxkIHByb2Nlc3MgUElEIHdpdGggd2FpdCBzdGF0dXMgVyBoYXMKLSAgIGNo YW5nZWQgaXRzIHN0YXR1czsgcmVjb3JkIHRoaXMgYW5kIHJldHVybiB0cnVlLgotCi0gICBJ ZiBQSUQgaXMgbmVnYXRpdmUsIGlnbm9yZSBXLCBhbmQgbG9vayBmb3Iga25vd24gY2hpbGQg cHJvY2Vzc2VzCi0gICBvZiBFbWFjcyB3aG9zZSBzdGF0dXMgaGF2ZSBjaGFuZ2VkLiAgRm9y IGVhY2ggb25lIGZvdW5kLCByZWNvcmQgaXRzIG5ldwotICAgc3RhdHVzLgorI2lmZGVmIFNJ R0NITEQKKworLyogVGhlIG1haW4gRW1hY3MgdGhyZWFkIHJlY29yZHMgY2hpbGQgcHJvY2Vz c2VzIGluIHRocmVlIHBsYWNlczoKKworICAgLSBWcHJvY2Vzc19hbGlzdCwgZm9yIGFzeW5j aHJvbm91cyBzdWJwcm9jZXNzZXMsIHdoaWNoIGFyZSBjaGlsZAorICAgICBwcm9jZXNzZXMg dmlzaWJsZSB0byBMaXNwLgorCisgICAtIGRlbGV0ZWRfcGlkX2xpc3QsIGZvciBjaGlsZCBw cm9jZXNzZXMgaW52aXNpYmxlIHRvIExpc3AsCisgICAgIHR5cGljYWxseSBiZWNhdXNlIG9m IGRlbGV0ZS1wcm9jZXNzLiAgVGhlc2UgYXJlIHJlY29yZGVkIHNvIHRoYXQKKyAgICAgdGhl IHByb2Nlc3NlcyBjYW4gYmUgcmVhcGVkIHdoZW4gdGhleSBleGl0LCBzbyB0aGF0IHRoZSBv cGVyYXRpbmcKKyAgICAgc3lzdGVtJ3MgcHJvY2VzcyB0YWJsZSBpcyBub3QgY2x1dHRlcmVk IGJ5IHpvbWJpZXMuCisKKyAgIC0gdGhlIGxvY2FsIHZhcmlhYmxlIFBJRCBpbiBGY2FsbF9w cm9jZXNzLCBjYWxsX3Byb2Nlc3NfY2xlYW51cCBhbmQKKyAgICAgY2FsbF9wcm9jZXNzX2tp bGwsIGZvciBzeW5jaHJvbm91cyBzdWJwcm9jZXNzZXMuCisgICAgIHJlY29yZF91bndpbmRf cHJvdGVjdCBpcyB1c2VkIHRvIG1ha2Ugc3VyZSB0aGlzIHByb2Nlc3MgaXMgbm90CisgICAg IGZvcmdvdHRlbjogaWYgdGhlIHVzZXIgaW50ZXJydXB0cyBjYWxsLXByb2Nlc3MgYW5kIHRo ZSBjaGlsZAorICAgICBwcm9jZXNzIHJlZnVzZXMgdG8gZXhpdCBpbW1lZGlhdGVseSBldmVu IHdpdGggdHdvIEMtZydzLAorICAgICBjYWxsX3Byb2Nlc3Nfa2lsbCBhZGRzIFBJRCdzIGNv bnRlbnRzIHRvIGRlbGV0ZWRfcGlkX2xpc3QgYmVmb3JlCisgICAgIHJldHVybmluZy4KKwor ICAgVGhlIG1haW4gRW1hY3MgdGhyZWFkIGludm9rZXMgd2FpdHBpZCBvbmx5IG9uIGNoaWxk IHByb2Nlc3NlcyB0aGF0CisgICBpdCBjcmVhdGVzIGFuZCB0aGF0IGhhdmUgbm90IGJlZW4g cmVhcGVkLiAgVGhpcyBhdm9pZCByYWNlcyBvbgorICAgcGxhdGZvcm1zIHN1Y2ggYXMgR1RL LCB3aGVyZSBvdGhlciB0aHJlYWRzIGNyZWF0ZSB0aGVpciBvd24KKyAgIHN1YnByb2Nlc3Nl cyB3aGljaCB0aGUgbWFpbiB0aHJlYWQgc2hvdWxkIG5vdCByZWFwLiAgRm9yIGV4YW1wbGUs CisgICBpZiB0aGUgbWFpbiB0aHJlYWQgYXR0ZW1wdGVkIHRvIHJlYXAgYW4gYWxyZWFkeS1y ZWFwZWQgY2hpbGQsIGl0CisgICBtaWdodCBpbmFkdmVydGVudGx5IHJlYXAgYSBHVEstY3Jl YXRlZCBwcm9jZXNzIHRoYXQgaGFwcGVuZWQgdG8KKyAgIGhhdmUgdGhlIHNhbWUgcHJvY2Vz cyBJRC4gICovCisKKy8qIEhhbmRsZSBhIFNJR0NITEQgc2lnbmFsIGJ5IGxvb2tpbmcgZm9y IGtub3duIGNoaWxkIHByb2Nlc3NlcyBvZgorICAgRW1hY3Mgd2hvc2Ugc3RhdHVzIGhhdmUg Y2hhbmdlZC4gIEZvciBlYWNoIG9uZSBmb3VuZCwgcmVjb3JkIGl0cworICAgbmV3IHN0YXR1 cy4KIAogICAgQWxsIHdlIGRvIGlzIGNoYW5nZSB0aGUgc3RhdHVzOyB3ZSBkbyBub3QgcnVu IHNlbnRpbmVscyBvciBwcmludAogICAgbm90aWZpY2F0aW9ucy4gIFRoYXQgaXMgc2F2ZWQg Zm9yIHRoZSBuZXh0IHRpbWUga2V5Ym9hcmQgaW5wdXQgaXMKQEAgLTYyMTEsMjAgKzYyMjQs MTUgQEAKICAgICoqIE1hbGxvYyBXQVJOSU5HOiBUaGlzIHNob3VsZCBuZXZlciBjYWxsIG1h bGxvYyBlaXRoZXIgZGlyZWN0bHkgb3IKICAgIGluZGlyZWN0bHk7IGlmIGl0IGRvZXMsIHRo YXQgaXMgYSBidWcgICovCiAKLXZvaWQKLXJlY29yZF9jaGlsZF9zdGF0dXNfY2hhbmdlIChw aWRfdCBwaWQsIGludCB3KQorc3RhdGljIHZvaWQKK2hhbmRsZV9jaGlsZF9zaWduYWwgKGlu dCBzaWcpCiB7Ci0jaWZkZWYgU0lHQ0hMRAotCi0gIC8qIFJlY29yZCBhdCBtb3N0IG9uZSBj aGlsZCBvbmx5IGlmIHdlIGFscmVhZHkga25vdyBvbmUgY2hpbGQgdGhhdAotICAgICBoYXMg ZXhpdGVkLiAgKi8KLSAgYm9vbCByZWNvcmRfYXRfbW9zdF9vbmVfY2hpbGQgPSAwIDw9IHBp ZDsKLQogICBMaXNwX09iamVjdCB0YWlsOwogCiAgIC8qIEZpbmQgdGhlIHByb2Nlc3MgdGhh dCBzaWduYWxlZCB1cywgYW5kIHJlY29yZCBpdHMgc3RhdHVzLiAgKi8KIAotICAvKiBUaGUg cHJvY2VzcyBjYW4gaGF2ZSBiZWVuIGRlbGV0ZWQgYnkgRmRlbGV0ZV9wcm9jZXNzLiAgKi8K KyAgLyogVGhlIHByb2Nlc3MgY2FuIGhhdmUgYmVlbiBkZWxldGVkIGJ5IEZkZWxldGVfcHJv Y2Vzcywgb3IgaGF2ZQorICAgICBiZWVuIHN0YXJ0ZWQgYXN5bmNocm9ub3VzbHkgYnkgRmNh bGxfcHJvY2Vzcy4gICovCiAgIGZvciAodGFpbCA9IGRlbGV0ZWRfcGlkX2xpc3Q7IENPTlNQ ICh0YWlsKTsgdGFpbCA9IFhDRFIgKHRhaWwpKQogICAgIHsKICAgICAgIGJvb2wgYWxsX3Bp ZHNfYXJlX2ZpeG51bXMKQEAgLTYyMzgsMTIgKzYyNDYsOCBAQAogCSAgICBkZWxldGVkX3Bp ZCA9IFhJTlQgKHhwaWQpOwogCSAgZWxzZQogCSAgICBkZWxldGVkX3BpZCA9IFhGTE9BVF9E QVRBICh4cGlkKTsKLQkgIGlmIChwcm9jZXNzX3N0YXR1c19yZXRyaWV2ZWQgKGRlbGV0ZWRf cGlkLCBwaWQsICZ3KSkKLQkgICAgewotCSAgICAgIFhTRVRDQVIgKHRhaWwsIFFuaWwpOwot CSAgICAgIGlmIChyZWNvcmRfYXRfbW9zdF9vbmVfY2hpbGQpCi0JCXJldHVybjsKLQkgICAg fQorCSAgaWYgKGNoaWxkX3N0YXR1c19jaGFuZ2VkIChkZWxldGVkX3BpZCwgMCwgMCkpCisJ ICAgIFhTRVRDQVIgKHRhaWwsIFFuaWwpOwogCX0KICAgICB9CiAKQEAgLTYyNTIsMTUgKzYy NTYsMTcgQEAKICAgICB7CiAgICAgICBMaXNwX09iamVjdCBwcm9jID0gWENEUiAoWENBUiAo dGFpbCkpOwogICAgICAgc3RydWN0IExpc3BfUHJvY2VzcyAqcCA9IFhQUk9DRVNTIChwcm9j KTsKLSAgICAgIGlmIChwLT5hbGl2ZSAmJiBwcm9jZXNzX3N0YXR1c19yZXRyaWV2ZWQgKHAt PnBpZCwgcGlkLCAmdykpCisgICAgICBpbnQgc3RhdHVzOworCisgICAgICBpZiAocC0+YWxp dmUgJiYgY2hpbGRfc3RhdHVzX2NoYW5nZWQgKHAtPnBpZCwgJnN0YXR1cywgV1VOVFJBQ0VE KSkKIAl7CiAJICAvKiBDaGFuZ2UgdGhlIHN0YXR1cyBvZiB0aGUgcHJvY2VzcyB0aGF0IHdh cyBmb3VuZC4gICovCiAJICBwLT50aWNrID0gKytwcm9jZXNzX3RpY2s7Ci0JICBwLT5yYXdf c3RhdHVzID0gdzsKKwkgIHAtPnJhd19zdGF0dXMgPSBzdGF0dXM7CiAJICBwLT5yYXdfc3Rh dHVzX25ldyA9IDE7CiAKIAkgIC8qIElmIHByb2Nlc3MgaGFzIHRlcm1pbmF0ZWQsIHN0b3Ag d2FpdGluZyBmb3IgaXRzIG91dHB1dC4gICovCi0JICBpZiAoV0lGU0lHTkFMRUQgKHcpIHx8 IFdJRkVYSVRFRCAodykpCisJICBpZiAoV0lGU0lHTkFMRUQgKHN0YXR1cykgfHwgV0lGRVhJ VEVEIChzdGF0dXMpKQogCSAgICB7CiAJICAgICAgaW50IGNsZWFyX2Rlc2NfZmxhZyA9IDA7 CiAJICAgICAgcC0+YWxpdmUgPSAwOwpAQCAtNjI3NCw0NCArNjI4MCw4IEBACiAJCSAgRkRf Q0xSIChwLT5pbmZkLCAmbm9uX2tleWJvYXJkX3dhaXRfbWFzayk7CiAJCX0KIAkgICAgfQot Ci0JICAvKiBUZWxsIHdhaXRfcmVhZGluZ19wcm9jZXNzX291dHB1dCB0aGF0IGl0IG5lZWRz IHRvIHdha2UgdXAgYW5kCi0JICAgICBsb29rIGFyb3VuZC4gICovCi0JICBpZiAoaW5wdXRf YXZhaWxhYmxlX2NsZWFyX3RpbWUpCi0JICAgICppbnB1dF9hdmFpbGFibGVfY2xlYXJfdGlt ZSA9IG1ha2VfZW1hY3NfdGltZSAoMCwgMCk7Ci0KLQkgIGlmIChyZWNvcmRfYXRfbW9zdF9v bmVfY2hpbGQpCi0JICAgIHJldHVybjsKIAl9CiAgICAgfQotCi0gIGlmICgwIDw9IHBpZCkK LSAgICB7Ci0gICAgICAvKiBUaGUgY2FsbGVyIHN1Y2Nlc3NmdWxseSB3YWl0ZWQgZm9yIGEg cGlkIGJ1dCBubyBhc3luY2hyb25vdXMKLQkgcHJvY2VzcyB3YXMgZm91bmQgZm9yIGl0LCBz byB0aGlzIGlzIGEgc3luY2hyb25vdXMgcHJvY2Vzcy4gICovCi0KLSAgICAgIHN5bmNoX3By b2Nlc3NfYWxpdmUgPSAwOwotCi0gICAgICAvKiBSZXBvcnQgdGhlIHN0YXR1cyBvZiB0aGUg c3luY2hyb25vdXMgcHJvY2Vzcy4gICovCi0gICAgICBpZiAoV0lGRVhJVEVEICh3KSkKLQlz eW5jaF9wcm9jZXNzX3JldGNvZGUgPSBXRVhJVFNUQVRVUyAodyk7Ci0gICAgICBlbHNlIGlm IChXSUZTSUdOQUxFRCAodykpCi0Jc3luY2hfcHJvY2Vzc190ZXJtc2lnID0gV1RFUk1TSUcg KHcpOwotCi0gICAgICAvKiBUZWxsIHdhaXRfcmVhZGluZ19wcm9jZXNzX291dHB1dCB0aGF0 IGl0IG5lZWRzIHRvIHdha2UgdXAgYW5kCi0JIGxvb2sgYXJvdW5kLiAgKi8KLSAgICAgIGlm IChpbnB1dF9hdmFpbGFibGVfY2xlYXJfdGltZSkKLQkqaW5wdXRfYXZhaWxhYmxlX2NsZWFy X3RpbWUgPSBtYWtlX2VtYWNzX3RpbWUgKDAsIDApOwotICAgIH0KLSNlbmRpZgotfQotCi0j aWZkZWYgU0lHQ0hMRAotCi1zdGF0aWMgdm9pZAotaGFuZGxlX2NoaWxkX3NpZ25hbCAoaW50 IHNpZykKLXsKLSAgcmVjb3JkX2NoaWxkX3N0YXR1c19jaGFuZ2UgKC0xLCAwKTsKIH0KIAog c3RhdGljIHZvaWQKCj09PSBtb2RpZmllZCBmaWxlICdzcmMvcHJvY2Vzcy5oJwotLS0gc3Jj L3Byb2Nlc3MuaAkyMDEyLTExLTI3IDAzOjEwOjMyICswMDAwCisrKyBzcmMvcHJvY2Vzcy5o CTIwMTItMTEtMjcgMTc6MDg6NTAgKzAwMDAKQEAgLTE4NSwyMyArMTg1LDYgQEAKIH0KICNl bmRpZgogCi0vKiBUcnVlIGlmIHdlIGFyZSBhYm91dCB0byBmb3JrIG9mZiBhIHN5bmNocm9u b3VzIHByb2Nlc3Mgb3IgaWYgd2UKLSAgIGFyZSB3YWl0aW5nIGZvciBpdC4gICovCi1leHRl cm4gYm9vbCBzeW5jaF9wcm9jZXNzX2FsaXZlOwotCi0vKiBDb21tdW5pY2F0ZSBleGl0IHN0 YXR1cyBvZiBzeW5jIHByb2Nlc3MgdG8gZnJvbSBzaWdjaGxkX2hhbmRsZXIKLSAgIHRvIEZj YWxsX3Byb2Nlc3MuICAqLwotCi0vKiBOb256ZXJvID0+IHRoaXMgaXMgYSBzdHJpbmcgZXhw bGFpbmluZyBkZWF0aCBvZiBzeW5jaHJvbm91cyBzdWJwcm9jZXNzLiAgKi8KLWV4dGVybiBj b25zdCBjaGFyICpzeW5jaF9wcm9jZXNzX2RlYXRoOwotCi0vKiBOb256ZXJvID0+IHRoaXMg aXMgdGhlIHNpZ25hbCBudW1iZXIgdGhhdCB0ZXJtaW5hdGVkIHRoZSBzdWJwcm9jZXNzLiAg Ki8KLWV4dGVybiBpbnQgc3luY2hfcHJvY2Vzc190ZXJtc2lnOwotCi0vKiBJZiBzeW5jaF9w cm9jZXNzX2RlYXRoIGlzIHplcm8sCi0gICB0aGlzIGlzIGV4aXQgY29kZSBvZiBzeW5jaHJv bm91cyBzdWJwcm9jZXNzLiAgKi8KLWV4dGVybiBpbnQgc3luY2hfcHJvY2Vzc19yZXRjb2Rl OwotCiAvKiBOb256ZXJvIG1lYW5zIGRvbid0IHJ1biBwcm9jZXNzIHNlbnRpbmVscy4gIFRo aXMgaXMgdXNlZAogICAgd2hlbiBleGl0aW5nLiAgKi8KIGV4dGVybiBpbnQgaW5oaWJpdF9z ZW50aW5lbHM7Cgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL3N5c2RlcC5jJwotLS0gc3JjL3N5 c2RlcC5jCTIwMTItMTEtMjcgMDM6MTA6MzIgKzAwMDAKKysrIHNyYy9zeXNkZXAuYwkyMDEy LTExLTI5IDAxOjExOjQ5ICswMDAwCkBAIC0yNjYsNDUgKzI2Niw3MSBAQAogCiAjaWZuZGVm IE1TRE9TCiAKLXN0YXRpYyB2b2lkCi13YWl0X2Zvcl90ZXJtaW5hdGlvbl8xIChwaWRfdCBw aWQsIGludCBpbnRlcnJ1cHRpYmxlKQorLyogV2FpdCBmb3IgdGhlIHN1YnByb2Nlc3Mgd2l0 aCBwcm9jZXNzIGlkIENISUxEIHRvIHRlcm1pbmF0ZSBvciBjaGFuZ2Ugc3RhdHVzLgorICAg Q0hJTEQgbXVzdCBiZSBhIGNoaWxkIHByb2Nlc3MgdGhhdCBoYXMgbm90IGJlZW4gcmVhcGVk LgorICAgSWYgU1RBVFVTIGlzIG5vbi1udWxsLCBzdG9yZSB0aGUgd2FpdHBpZC1zdHlsZSBl eGl0IHN0YXR1cyBpbnRvICpTVEFUVVMKKyAgIGFuZCB0ZWxsIHdhaXRfcmVhZGluZ19wcm9j ZXNzX291dHB1dCB0aGF0IGl0IG5lZWRzIHRvIGxvb2sgYXJvdW5kLgorICAgVXNlIHdhaXRw aWQtc3R5bGUgT1BUSU9OUyB3aGVuIHdhaXRpbmcuCisgICBJZiBJTlRFUlJVUFRJQkxFLCB0 aGlzIGZ1bmN0aW9uIGlzIGludGVycnVwdGlibGUgYnkgYSBzaWduYWwuCisKKyAgIFJldHVy biBDSElMRCBpZiBzdWNjZXNzZnVsLCAwIGlmIG5vIHN0YXR1cyBpcyBhdmFpbGFibGU7Cisg ICB0aGUgbGF0dGVyIGlzIHBvc3NpYmxlIG9ubHkgd2hlbiBvcHRpb25zICYgTk9IQU5HLiAg Ki8KK3N0YXRpYyBwaWRfdAorZ2V0X2NoaWxkX3N0YXR1cyAocGlkX3QgY2hpbGQsIGludCAq c3RhdHVzLCBpbnQgb3B0aW9ucywgYm9vbCBpbnRlcnJ1cHRpYmxlKQogewotICB3aGlsZSAo MSkKKyAgcGlkX3QgcGlkOworCisgIC8qIEludm9rZSB3YWl0cGlkIG9ubHkgd2l0aCBhIGtu b3duIHByb2Nlc3MgSUQ7IGRvIG5vdCBpbnZva2UKKyAgICAgd2FpdHBpZCB3aXRoIGEgbm9u cG9zaXRpdmUgYXJndW1lbnQuICBPdGhlcndpc2UsIEVtYWNzIG1pZ2h0CisgICAgIHJlYXAg YW4gdW53YW50ZWQgcHJvY2VzcyBieSBtaXN0YWtlLiAgRm9yIGV4YW1wbGUsIGludm9raW5n CisgICAgIHdhaXRwaWQgKC0xLCAuLi4pIGNhbiBtZXNzIHVwIGdsaWIgYnkgcmVhcGluZyBn bGliJ3Mgc3VicHJvY2Vzc2VzLAorICAgICBzbyB0aGF0IGFub3RoZXIgdGhyZWFkIHJ1bm5p bmcgZ2xpYiB3b24ndCBmaW5kIHRoZW0uICAqLworICBlYXNzZXJ0ICgwIDwgY2hpbGQpOwor CisgIHdoaWxlICgocGlkID0gd2FpdHBpZCAoY2hpbGQsIHN0YXR1cywgb3B0aW9ucykpIDwg MCkKICAgICB7Ci0gICAgICBpbnQgc3RhdHVzOwotICAgICAgaW50IHdhaXRfcmVzdWx0ID0g d2FpdHBpZCAocGlkLCAmc3RhdHVzLCAwKTsKLSAgICAgIGlmICh3YWl0X3Jlc3VsdCA8IDAp Ci0JewotCSAgaWYgKGVycm5vICE9IEVJTlRSKQotCSAgICBicmVhazsKLQl9Ci0gICAgICBl bHNlCi0JewotCSAgcmVjb3JkX2NoaWxkX3N0YXR1c19jaGFuZ2UgKHdhaXRfcmVzdWx0LCBz dGF0dXMpOwotCSAgYnJlYWs7Ci0JfQorICAgICAgLyogQ0hJTEQgbXVzdCBiZSBhIGNoaWxk IHByb2Nlc3MgdGhhdCBoYXMgbm90IGJlZW4gcmVhcGVkLCBhbmQKKwkgU1RBVFVTIGFuZCBP UFRJT05TIG11c3QgYmUgdmFsaWQuICAqLworICAgICAgZWFzc2VydCAoZXJybm8gPT0gRUlO VFIpOwogCiAgICAgICAvKiBOb3RlOiB0aGUgTVMtV2luZG93cyBlbXVsYXRpb24gb2Ygd2Fp dHBpZCBjYWxscyBRVUlUCiAJIGludGVybmFsbHkuICAqLwogICAgICAgaWYgKGludGVycnVw dGlibGUpCiAJUVVJVDsKICAgICB9Ci19Ci0KLS8qIFdhaXQgZm9yIHN1YnByb2Nlc3Mgd2l0 aCBwcm9jZXNzIGlkIGBwaWQnIHRvIHRlcm1pbmF0ZSBhbmQKLSAgIG1ha2Ugc3VyZSBpdCB3 aWxsIGdldCBlbGltaW5hdGVkIChub3QgcmVtYWluIGZvcmV2ZXIgYXMgYSB6b21iaWUpICov Ci0KLXZvaWQKLXdhaXRfZm9yX3Rlcm1pbmF0aW9uIChwaWRfdCBwaWQpCi17Ci0gIHdhaXRf Zm9yX3Rlcm1pbmF0aW9uXzEgKHBpZCwgMCk7Ci19Ci0KLS8qIExpa2UgdGhlIGFib3ZlLCBi dXQgYWxsb3cga2V5Ym9hcmQgaW50ZXJydXB0aW9uLiAqLwotdm9pZAotaW50ZXJydXB0aWJs ZV93YWl0X2Zvcl90ZXJtaW5hdGlvbiAocGlkX3QgcGlkKQotewotICB3YWl0X2Zvcl90ZXJt aW5hdGlvbl8xIChwaWQsIDEpOworCisgIC8qIElmIHN1Y2Nlc3NmdWwgYW5kIHN0YXR1cyBp cyByZXF1ZXN0ZWQsIHRlbGwgd2FpdF9yZWFkaW5nX3Byb2Nlc3Nfb3V0cHV0CisgICAgIHRo YXQgaXQgbmVlZHMgdG8gd2FrZSB1cCBhbmQgbG9vayBhcm91bmQuICAqLworICBpZiAocGlk ICYmIHN0YXR1cyAmJiBpbnB1dF9hdmFpbGFibGVfY2xlYXJfdGltZSkKKyAgICAqaW5wdXRf YXZhaWxhYmxlX2NsZWFyX3RpbWUgPSBtYWtlX2VtYWNzX3RpbWUgKDAsIDApOworCisgIHJl dHVybiBwaWQ7Cit9CisKKy8qIFdhaXQgZm9yIHRoZSBzdWJwcm9jZXNzIHdpdGggcHJvY2Vz cyBpZCBDSElMRCB0byB0ZXJtaW5hdGUuCisgICBDSElMRCBtdXN0IGJlIGEgY2hpbGQgcHJv Y2VzcyB0aGF0IGhhcyBub3QgYmVlbiByZWFwZWQuCisgICBJZiBTVEFUVVMgaXMgbm9uLW51 bGwsIHN0b3JlIHRoZSB3YWl0cGlkLXN0eWxlIGV4aXQgc3RhdHVzIGludG8gKlNUQVRVUwor ICAgYW5kIHRlbGwgd2FpdF9yZWFkaW5nX3Byb2Nlc3Nfb3V0cHV0IHRoYXQgaXQgbmVlZHMg dG8gbG9vayBhcm91bmQuCisgICBJZiBJTlRFUlJVUFRJQkxFLCB0aGlzIGZ1bmN0aW9uIGlz IGludGVycnVwdGlibGUgYnkgYSBzaWduYWwuICAqLwordm9pZAord2FpdF9mb3JfdGVybWlu YXRpb24gKHBpZF90IGNoaWxkLCBpbnQgKnN0YXR1cywgYm9vbCBpbnRlcnJ1cHRpYmxlKQor eworICBnZXRfY2hpbGRfc3RhdHVzIChjaGlsZCwgc3RhdHVzLCAwLCBpbnRlcnJ1cHRpYmxl KTsKK30KKworLyogUmVwb3J0IHdoZXRoZXIgdGhlIHN1YnByb2Nlc3Mgd2l0aCBwcm9jZXNz IGlkIENISUxEIGhhcyBjaGFuZ2VkIHN0YXR1cy4KKyAgIFRlcm1pbmF0aW9uIGNvdW50cyBh cyBhIGNoYW5nZSBvZiBzdGF0dXMuCisgICBDSElMRCBtdXN0IGJlIGEgY2hpbGQgcHJvY2Vz cyB0aGF0IGhhcyBub3QgYmVlbiByZWFwZWQuCisgICBJZiBTVEFUVVMgaXMgbm9uLW51bGws IHN0b3JlIHRoZSB3YWl0cGlkLXN0eWxlIGV4aXQgc3RhdHVzIGludG8gKlNUQVRVUworICAg YW5kIHRlbGwgd2FpdF9yZWFkaW5nX3Byb2Nlc3Nfb3V0cHV0IHRoYXQgaXQgbmVlZHMgdG8g bG9vayBhcm91bmQuCisgICBVc2Ugd2FpdHBpZC1zdHlsZSBPUFRJT05TIHRvIGNoZWNrIHN0 YXR1cywgYnV0IGRvIG5vdCB3YWl0LgorCisgICBSZXR1cm4gQ0hJTEQgaWYgc3VjY2Vzc2Z1 bCwgMCBpZiBubyBzdGF0dXMgaXMgYXZhaWxhYmxlIGJlY2F1c2UKKyAgIHRoZSBwcm9jZXNz J3Mgc3RhdGUgaGFzIG5vdCBjaGFuZ2VkLiAgKi8KK3BpZF90CitjaGlsZF9zdGF0dXNfY2hh bmdlZCAocGlkX3QgY2hpbGQsIGludCAqc3RhdHVzLCBpbnQgb3B0aW9ucykKK3sKKyAgcmV0 dXJuIGdldF9jaGlsZF9zdGF0dXMgKGNoaWxkLCBzdGF0dXMsIFdOT0hBTkcgfCBvcHRpb25z LCAwKTsKIH0KIAogLyoKQEAgLTQ1NCw2ICs0ODAsNyBAQAogICBjaGFyIG9sZHdkW01BWFBB VEhMRU4rMV07IC8qIEZpeGVkIGxlbmd0aCBpcyBzYWZlIG9uIE1TRE9TLiAgKi8KICNlbmRp ZgogICBwaWRfdCBwaWQ7CisgIGludCBzdGF0dXM7CiAgIHN0cnVjdCBzYXZlX3NpZ25hbCBz YXZlZF9oYW5kbGVyc1s1XTsKICAgTGlzcF9PYmplY3QgZGlyOwogICB1bnNpZ25lZCBjaGFy ICp2b2xhdGlsZSBzdHJfdm9sYXRpbGUgPSAwOwpAQCAtNDkxLDcgKzUxOCw2IEBACiAjaWZk ZWYgRE9TX05UCiAgIHBpZCA9IDA7CiAgIHNhdmVfc2lnbmFsX2hhbmRsZXJzIChzYXZlZF9o YW5kbGVycyk7Ci0gIHN5bmNoX3Byb2Nlc3NfYWxpdmUgPSAxOwogI2Vsc2UKICAgcGlkID0g dmZvcmsgKCk7CiAgIGlmIChwaWQgPT0gLTEpCkBAIC01NjAsMTQgKzU4NiwxMiBAQAogICAv KiBEbyB0aGlzIG5vdyBpZiB3ZSBkaWQgbm90IGRvIGl0IGJlZm9yZS4gICovCiAjaWZuZGVm IE1TRE9TCiAgIHNhdmVfc2lnbmFsX2hhbmRsZXJzIChzYXZlZF9oYW5kbGVycyk7Ci0gIHN5 bmNoX3Byb2Nlc3NfYWxpdmUgPSAxOwogI2VuZGlmCiAKICNpZm5kZWYgRE9TX05UCi0gIHdh aXRfZm9yX3Rlcm1pbmF0aW9uIChwaWQpOworICB3YWl0X2Zvcl90ZXJtaW5hdGlvbiAocGlk LCAmc3RhdHVzLCAwKTsKICNlbmRpZgogICByZXN0b3JlX3NpZ25hbF9oYW5kbGVycyAoc2F2 ZWRfaGFuZGxlcnMpOwotICBzeW5jaF9wcm9jZXNzX2FsaXZlID0gMDsKIH0KIAogc3RhdGlj IHZvaWQKCj09PSBtb2RpZmllZCBmaWxlICdzcmMvc3lzd2FpdC5oJwotLS0gc3JjL3N5c3dh aXQuaAkyMDEyLTA5LTIzIDIyOjI1OjIyICswMDAwCisrKyBzcmMvc3lzd2FpdC5oCTIwMTIt MTEtMjkgMDE6MTE6NDkgKzAwMDAKQEAgLTIzLDYgKzIzLDcgQEAKICNpZm5kZWYgRU1BQ1Nf U1lTV0FJVF9ICiAjZGVmaW5lIEVNQUNTX1NZU1dBSVRfSAogCisjaW5jbHVkZSA8c3RkYm9v bC5oPgogI2luY2x1ZGUgPHN5cy90eXBlcy5oPgogCiAjaWZkZWYgSEFWRV9TWVNfV0FJVF9I CS8qIFdlIGhhdmUgc3lzL3dhaXQuaCB3aXRoIFBPU0lYb2lkIGRlZmluaXRpb25zLiAqLwpA QCAtNTIsMTAgKzUzLDEwIEBACiAjZW5kaWYKIAogLyogRGVmaW5lZCBpbiBwcm9jZXNzLmMu ICAqLwotZXh0ZXJuIHZvaWQgcmVjb3JkX2NoaWxkX3N0YXR1c19jaGFuZ2UgKHBpZF90LCBp bnQpOworZXh0ZXJuIHZvaWQgcmVjb3JkX2RlbGV0ZWRfcGlkIChwaWRfdCk7CiAKIC8qIERl ZmluZWQgaW4gc3lzZGVwLmMuICAqLwotZXh0ZXJuIHZvaWQgd2FpdF9mb3JfdGVybWluYXRp b24gKHBpZF90KTsKLWV4dGVybiB2b2lkIGludGVycnVwdGlibGVfd2FpdF9mb3JfdGVybWlu YXRpb24gKHBpZF90KTsKK2V4dGVybiB2b2lkIHdhaXRfZm9yX3Rlcm1pbmF0aW9uIChwaWRf dCwgaW50ICosIGJvb2wpOworZXh0ZXJuIHBpZF90IGNoaWxkX3N0YXR1c19jaGFuZ2VkIChw aWRfdCwgaW50ICosIGludCk7CiAKICNlbmRpZiAvKiBFTUFDU19TWVNXQUlUX0ggKi8KCj09 PSBtb2RpZmllZCBmaWxlICdzcmMvdzMycHJvYy5jJwotLS0gc3JjL3czMnByb2MuYwkyMDEy LTExLTI3IDAzOjEwOjMyICswMDAwCisrKyBzcmMvdzMycHJvYy5jCTIwMTItMTEtMjkgMDE6 MTE6NDkgKzAwMDAKQEAgLTEyNzQsMzMgKzEyNzQsNyBAQAogI2VuZGlmCiAKICAgaWYgKHN0 YXR1cykKLSAgICB7Ci0gICAgICAqc3RhdHVzID0gcmV0dmFsOwotICAgIH0KLSAgZWxzZSBp ZiAoc3luY2hfcHJvY2Vzc19hbGl2ZSkKLSAgICB7Ci0gICAgICBzeW5jaF9wcm9jZXNzX2Fs aXZlID0gMDsKLQotICAgICAgLyogUmVwb3J0IHRoZSBzdGF0dXMgb2YgdGhlIHN5bmNocm9u b3VzIHByb2Nlc3MuICAqLwotICAgICAgaWYgKFdJRkVYSVRFRCAocmV0dmFsKSkKLQlzeW5j aF9wcm9jZXNzX3JldGNvZGUgPSBXRVhJVFNUQVRVUyAocmV0dmFsKTsKLSAgICAgIGVsc2Ug aWYgKFdJRlNJR05BTEVEIChyZXR2YWwpKQotCXsKLQkgIGludCBjb2RlID0gV1RFUk1TSUcg KHJldHZhbCk7Ci0JICBjb25zdCBjaGFyICpzaWduYW1lOwotCi0JICBzeW5jaHJvbml6ZV9z eXN0ZW1fbWVzc2FnZXNfbG9jYWxlICgpOwotCSAgc2lnbmFtZSA9IHN0cnNpZ25hbCAoY29k ZSk7Ci0KLQkgIGlmIChzaWduYW1lID09IDApCi0JICAgIHNpZ25hbWUgPSAidW5rbm93biI7 Ci0KLQkgIHN5bmNoX3Byb2Nlc3NfZGVhdGggPSBzaWduYW1lOwotCX0KLQotICAgICAgcmVh cF9zdWJwcm9jZXNzIChjcCk7Ci0gICAgfQotCisgICAgKnN0YXR1cyA9IHJldHZhbDsKICAg cmVhcF9zdWJwcm9jZXNzIChjcCk7CiAKICAgcmV0dXJuIHBpZDsKCg== --------------090006010900090003030103-- From unknown Sat Jun 14 19:12:50 2025 X-Loop: help-debbugs@gnu.org Subject: bug#9488: 24.3.50; Zombie process left after call-process Resent-From: Eli Zaretskii Original-Sender: debbugs-submit-bounces@debbugs.gnu.org Resent-CC: bug-gnu-emacs@gnu.org Resent-Date: Thu, 29 Nov 2012 18:07:01 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 9488 X-GNU-PR-Package: emacs X-GNU-PR-Keywords: patch To: Paul Eggert Cc: 9488@debbugs.gnu.org, hanche@math.ntnu.no, 12980@debbugs.gnu.org Reply-To: Eli Zaretskii Received: via spool by 9488-submit@debbugs.gnu.org id=B9488.135421241227183 (code B ref 9488); Thu, 29 Nov 2012 18:07:01 +0000 Received: (at 9488) by debbugs.gnu.org; 29 Nov 2012 18:06:52 +0000 Received: from localhost ([127.0.0.1]:45492 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Te8Vf-00074O-Ic for submit@debbugs.gnu.org; Thu, 29 Nov 2012 13:06:51 -0500 Received: from mtaout22.012.net.il ([80.179.55.172]:38624) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Te8VZ-000743-Ox; Thu, 29 Nov 2012 13:06:47 -0500 Received: from conversion-daemon.a-mtaout22.012.net.il by a-mtaout22.012.net.il (HyperSendmail v2007.08) id <0ME900800GR9W400@a-mtaout22.012.net.il>; Thu, 29 Nov 2012 20:04:34 +0200 (IST) Received: from HOME-C4E4A596F7 ([87.69.4.28]) by a-mtaout22.012.net.il (HyperSendmail v2007.08) with ESMTPA id <0ME9008QPGVMW700@a-mtaout22.012.net.il>; Thu, 29 Nov 2012 20:04:34 +0200 (IST) Date: Thu, 29 Nov 2012 20:04:55 +0200 From: Eli Zaretskii In-reply-to: <50B6C8B0.3000403@cs.ucla.edu> X-012-Sender: halo1@inter.net.il Message-id: <83pq2wuvy0.fsf@gnu.org> References: <50B3EF71.3020805@cs.ucla.edu> <83ehjfxcg7.fsf@gnu.org> <50B6C8B0.3000403@cs.ucla.edu> X-Spam-Score: 1.5 (+) X-Spam-Report: Spam detection software, running on the system "debbugs.gnu.org", has identified this incoming email as possible spam. The original message has been attached to this so you can view it (if it isn't spam) or label similar future email. If you have any questions, see the administrator of that system for details. Content preview: > Date: Wed, 28 Nov 2012 18:30:08 -0800 > From: Paul Eggert > CC: hanche@math.ntnu.no, 12980@debbugs.gnu.org, 9488@debbugs.gnu.org > > > The feature, whereby this function (call-process) could return a > > description of errno, is hereby lost. That's quite nasty in the MSDOS > > case > > That feature is supported only by MS-DOS, right? [...] Content analysis details: (1.5 points, 10.0 required) pts rule name description ---- ---------------------- -------------------------------------------------- -0.0 RCVD_IN_DNSWL_NONE RBL: Sender listed at http://www.dnswl.org/, no trust [80.179.55.172 listed in list.dnswl.org] 0.7 SPF_SOFTFAIL SPF: sender does not match SPF record (softfail) 0.8 BAYES_50 BODY: Bayes spam probability is 40 to 60% [score: 0.4983] X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: 1.5 (+) X-Spam-Report: Spam detection software, running on the system "debbugs.gnu.org", has identified this incoming email as possible spam. The original message has been attached to this so you can view it (if it isn't spam) or label similar future email. If you have any questions, see the administrator of that system for details. Content preview: > Date: Wed, 28 Nov 2012 18:30:08 -0800 > From: Paul Eggert > CC: hanche@math.ntnu.no, 12980@debbugs.gnu.org, 9488@debbugs.gnu.org > > > The feature, whereby this function (call-process) could return a > > description of errno, is hereby lost. That's quite nasty in the MSDOS > > case > > That feature is supported only by MS-DOS, right? [...] Content analysis details: (1.5 points, 10.0 required) pts rule name description ---- ---------------------- -------------------------------------------------- -0.0 RCVD_IN_DNSWL_NONE RBL: Sender listed at http://www.dnswl.org/, no trust [80.179.55.172 listed in list.dnswl.org] 0.7 SPF_SOFTFAIL SPF: sender does not match SPF record (softfail) 0.8 BAYES_50 BODY: Bayes spam probability is 40 to 60% [score: 0.4272] > Date: Wed, 28 Nov 2012 18:30:08 -0800 > From: Paul Eggert > CC: hanche@math.ntnu.no, 12980@debbugs.gnu.org, 9488@debbugs.gnu.org > > > The feature, whereby this function (call-process) could return a > > description of errno, is hereby lost. That's quite nasty in the MSDOS > > case > > That feature is supported only by MS-DOS, right? Yes, I think so. > On all other platforms an error is thrown. Anyway, the new patch > attempts to preserve the MS-DOS behavior. Thanks. > > Why is this eassert a good idea? We don't need to enforce the Posix > > spec at a price of crashing Emacs on users, do we? What bad things > > can happen if you see some other errno here? > > It's not a question of enforcing Posix semantics. It's a > question of catching potentially serious internal > programming errors in Emacs. That part of the code has been > completely rewritten, so the details of the comment is moot. > However, the new code has an "eassert (errno == EINTR)" in > the new get_child_status function. I preceded that with a > comment to try to help explain why the eassert is there. Here's the comment: > + /* CHILD must be a child process that has not been reaped, and > + STATUS and OPTIONS must be valid. */ > + eassert (errno == EINTR); Are we sure that either CHILD will have exited at this point, or else OPTIONS won't include WNOHANG? Can this function be ever called if neither of these conditions is true? > > it would be nice to have somewhere a commentary with an > > overview of how termination of child processes is handled. > > I added some, before handle_child_signal. Thanks. > - if (synch_process_termsig) > + if (WIFSIGNALED (status)) > { > const char *signame; > > synchronize_system_messages_locale (); > - signame = strsignal (synch_process_termsig); > + signame = strsignal (WTERMSIG (status)); > > if (signame == 0) > signame = "unknown"; > > - synch_process_death = signame; > + return code_convert_string_norecord (build_string (signame), > + Vlocale_coding_system, 0); > } > > - if (synch_process_death) > - return code_convert_string_norecord (build_string (synch_process_death), > - Vlocale_coding_system, 0); > - return make_number (synch_process_retcode); > + eassert (WIFEXITED (status)); > + return make_number (WEXITSTATUS (status)); The use of WIF* macros here, in particular WIFSIGNALED and WTERMSIG, will probably require more accurate definitions of these for Windows (currently, they are quite naive and therefore wrong). But that can wait. Otherwise, I see no problems related to Windows. Thanks! From unknown Sat Jun 14 19:12:50 2025 X-Loop: help-debbugs@gnu.org Subject: bug#9488: 24.3.50; Zombie process left after call-process Resent-From: Paul Eggert Original-Sender: debbugs-submit-bounces@debbugs.gnu.org Resent-CC: bug-gnu-emacs@gnu.org Resent-Date: Thu, 29 Nov 2012 20:31:02 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 9488 X-GNU-PR-Package: emacs X-GNU-PR-Keywords: patch To: Eli Zaretskii Cc: 9488@debbugs.gnu.org, hanche@math.ntnu.no, 12980@debbugs.gnu.org Received: via spool by 9488-submit@debbugs.gnu.org id=B9488.13542210328212 (code B ref 9488); Thu, 29 Nov 2012 20:31:02 +0000 Received: (at 9488) by debbugs.gnu.org; 29 Nov 2012 20:30:32 +0000 Received: from localhost ([127.0.0.1]:45638 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1TeAkh-00028K-UA for submit@debbugs.gnu.org; Thu, 29 Nov 2012 15:30:32 -0500 Received: from smtp.cs.ucla.edu ([131.179.128.62]:43297) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1TeAkd-000285-St; Thu, 29 Nov 2012 15:30:29 -0500 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 9EF4BA60008; Thu, 29 Nov 2012 12:28:25 -0800 (PST) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 8TskRWL55zWr; Thu, 29 Nov 2012 12:28:25 -0800 (PST) Received: from penguin.cs.ucla.edu (Penguin.CS.UCLA.EDU [131.179.64.200]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 3EF19A60005; Thu, 29 Nov 2012 12:28:25 -0800 (PST) Message-ID: <50B7C568.7040108@cs.ucla.edu> Date: Thu, 29 Nov 2012 12:28:24 -0800 From: Paul Eggert User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/17.0 Thunderbird/17.0 MIME-Version: 1.0 References: <50B3EF71.3020805@cs.ucla.edu> <83ehjfxcg7.fsf@gnu.org> <50B6C8B0.3000403@cs.ucla.edu> <83pq2wuvy0.fsf@gnu.org> In-Reply-To: <83pq2wuvy0.fsf@gnu.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.9 (-) On 11/29/12 10:04, Eli Zaretskii wrote: >> + /* CHILD must be a child process that has not been reaped, and >> + STATUS and OPTIONS must be valid. */ >> + eassert (errno == EINTR); > > Are we sure that either CHILD will have exited at this point, or else > OPTIONS won't include WNOHANG? It's unlikely that CHILD will have exited at this point. That can happen only if CHILD exited after the immediately-preceding waitpid call and before this eassert. In such a case, CHILD has exited but has not been reaped. It's common for OPTIONS to not include WNOHANG (wait_for_termination does this), and when that happens it's almost always the case that CHILD has not exited at this point. > Can this function be ever called if > neither of these conditions is true? By "this function" I assume you mean get_child_status. Yes, it's quite common. For example, Fcall_process invokes wait_for_termination, and it's common for wait_for_termination to invoke get_child_status before CHILD has exited, and without WNOHANG in OPTIONS. From unknown Sat Jun 14 19:12:50 2025 MIME-Version: 1.0 X-Mailer: MIME-tools 5.428 (Entity 5.428) X-Loop: help-debbugs@gnu.org From: help-debbugs@gnu.org (GNU bug Tracking System) To: Taylor R Campbell Subject: bug#9488: closed (Re: 24.3.50; Zombie process left after call-process) Message-ID: References: <50BD1E0F.6020902@cs.ucla.edu> <20110912201804.19D3EE4057@pluto.mumble.net> X-Gnu-PR-Message: they-closed 9488 X-Gnu-PR-Package: emacs X-Gnu-PR-Keywords: patch Reply-To: 9488@debbugs.gnu.org Date: Mon, 03 Dec 2012 21:51:03 +0000 Content-Type: multipart/mixed; boundary="----------=_1354571463-8575-1" This is a multi-part message in MIME format... ------------=_1354571463-8575-1 Content-Disposition: inline Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Your bug report #9488: 23.2; `call-process' races with SIGCHLD handler which was filed against the emacs package, has been closed. The explanation is attached below, along with your original report. If you require more details, please reply to 9488@debbugs.gnu.org. --=20 9488: http://debbugs.gnu.org/cgi/bugreport.cgi?bug=3D9488 GNU Bug Tracking System Contact help-debbugs@gnu.org with problems ------------=_1354571463-8575-1 Content-Type: message/rfc822 Content-Disposition: inline Content-Transfer-Encoding: 7bit Received: (at 9488-done) by debbugs.gnu.org; 3 Dec 2012 21:50:31 +0000 Received: from localhost ([127.0.0.1]:52027 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1TfduI-0002DO-IB for submit@debbugs.gnu.org; Mon, 03 Dec 2012 16:50:31 -0500 Received: from smtp.cs.ucla.edu ([131.179.128.62]:54660) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1TfduD-0002D8-Ae; Mon, 03 Dec 2012 16:50:26 -0500 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 381D539E8105; Mon, 3 Dec 2012 13:48:00 -0800 (PST) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 5Kczma3lq6Lh; Mon, 3 Dec 2012 13:47:59 -0800 (PST) Received: from penguin.cs.ucla.edu (Penguin.CS.UCLA.EDU [131.179.64.200]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id DD2EA39E8008; Mon, 3 Dec 2012 13:47:59 -0800 (PST) Message-ID: <50BD1E0F.6020902@cs.ucla.edu> Date: Mon, 03 Dec 2012 13:47:59 -0800 From: Paul Eggert User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/17.0 Thunderbird/17.0 MIME-Version: 1.0 To: 12980-done@debbugs.gnu.org, 9488-done@debbugs.gnu.org Subject: Re: 24.3.50; Zombie process left after call-process Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.5 (-) X-Debbugs-Envelope-To: 9488-done X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.5 (-) No further comment, so I installed the patch as Emacs trunk bzr 111081 and am marking bugs 9488 and 12980 as done. ------------=_1354571463-8575-1 Content-Type: message/rfc822 Content-Disposition: inline Content-Transfer-Encoding: 7bit Received: (at submit) by debbugs.gnu.org; 12 Sep 2011 20:27:25 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1R3D6C-00065X-LH for submit@debbugs.gnu.org; Mon, 12 Sep 2011 16:27:25 -0400 Received: from eggs.gnu.org ([140.186.70.92]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1R3D1Y-0005yy-9R for submit@debbugs.gnu.org; Mon, 12 Sep 2011 16:22:37 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1R3CxH-0005nH-36 for submit@debbugs.gnu.org; Mon, 12 Sep 2011 16:18:13 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-3.1 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_LOW, RP_MATCHES_RCVD autolearn=unavailable version=3.3.1 Received: from lists.gnu.org ([140.186.70.17]:34370) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1R3CxH-0005nD-1h for submit@debbugs.gnu.org; Mon, 12 Sep 2011 16:18:11 -0400 Received: from eggs.gnu.org ([140.186.70.92]:41839) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1R3CxG-0005mo-3j for bug-gnu-emacs@gnu.org; Mon, 12 Sep 2011 16:18:10 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1R3CxE-0005mj-QC for bug-gnu-emacs@gnu.org; Mon, 12 Sep 2011 16:18:10 -0400 Received: from pluto.mumble.net ([206.123.75.20]:42164) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1R3CxE-0005mG-Ke for bug-gnu-emacs@gnu.org; Mon, 12 Sep 2011 16:18:08 -0400 Received: by pluto.mumble.net (Postfix, from userid 1014) id 19D3EE4057; Mon, 12 Sep 2011 20:18:04 +0000 (UTC) From: Taylor R Campbell To: bug-gnu-emacs@gnu.org Subject: 23.2; `call-process' races with SIGCHLD handler Date: Mon, 12 Sep 2011 20:14:11 +0000 User-Agent: IMAIL/1.21; Edwin/3.116; MIT-Scheme/9.1 MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit Message-Id: <20110912201804.19D3EE4057@pluto.mumble.net> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6 (newer, 3) X-Received-From: 140.186.70.17 X-Spam-Score: -6.6 (------) X-Debbugs-Envelope-To: submit X-Mailman-Approved-At: Mon, 12 Sep 2011 16:27:24 -0400 X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -6.6 (------) `call-process' relies on `wait_for_termination' to block until the SIGCHLD handler has run for the synchronous subprocess. But this is not the condition that `wait_for_termination' guarantees on exit. Rather, if `wait_for_termination' returns, then either (a) there is no process having the same pid as the child had, or (b) a SIGCHLD has been delivered. If the subprocess has died, but no SIGCHLD has been delivered yet, then `wait_for_termination' may return even though the SIGCHLD handler has yet to run. As an aside, these conditions are not sufficient for `wait_for_termination' to return: it may block indefinitely if the operating system has already delivered SIGCHLD and reused the pid before control enters `wait_for_termination'. I have not observed indefinite blocking behaviour in practice, but only because pids don't get reused very fast. What I have observed is process exit values of 0 that should have been nonzero on GNU Emacs 23.2.1 (i386--netbsdelf, X toolkit) of 2011-03-02. I noticed this because `M-x grep' sometimes prompts me with `grep -nH' and sometimes with `grep -nH -e', in turn because (call-process "grep" nil nil nil "-e" "/dev/null") sometimes returns 0 and sometimes returns 1 depending on who wins the race. I have not tested newer versions of GNU Emacs, but a cursory glance at the code suggests that while the relevant subprocess code has grown more unmaintainably complicated, the problem persists. ------------=_1354571463-8575-1--