From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.6 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0AB42C35DE1 for ; Tue, 25 Feb 2020 13:25:14 +0000 (UTC) Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id BA93420726 for ; Tue, 25 Feb 2020 13:25:13 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="aPxvAm3t" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org BA93420726 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=qemu-devel-bounces+qemu-devel=archiver.kernel.org@nongnu.org Received: from localhost ([::1]:55672 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1j6aD2-000115-TL for qemu-devel@archiver.kernel.org; Tue, 25 Feb 2020 08:25:12 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:60602) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1j6Zhh-0007QJ-4c for qemu-devel@nongnu.org; Tue, 25 Feb 2020 07:52:52 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1j6Zha-0001Hh-93 for qemu-devel@nongnu.org; Tue, 25 Feb 2020 07:52:49 -0500 Received: from us-smtp-1.mimecast.com ([207.211.31.81]:36524 helo=us-smtp-delivery-1.mimecast.com) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1j6ZhZ-0001DU-ID for qemu-devel@nongnu.org; Tue, 25 Feb 2020 07:52:41 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1582635154; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=1H5OPfKRh44KkyAsiRb48VNd1UWqDOE2wt/zeMaIJQc=; b=aPxvAm3tBcGIIDfQL/u6HOCMCwJrCbC9M9F5vqQa7FmMbOt+f9+ajxhl0V/GRDtGnZMwUP OQgFcczkRgUMHHitu8u6E7Ox3oo2UQ9etpfusNinKVpMnYb3tNqKXwhPfZOARwBaWn4FJr swFMmMNnpIAETKyY9OLHjslrqFINWUs= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-365-2e9ZiuggOryDCa0mSFpFLw-1; Tue, 25 Feb 2020 07:52:29 -0500 X-MC-Unique: 2e9ZiuggOryDCa0mSFpFLw-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id C5F111005F70; Tue, 25 Feb 2020 12:52:27 +0000 (UTC) Received: from blackfin.pond.sub.org (ovpn-116-129.ams2.redhat.com [10.36.116.129]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 654275C1D6; Tue, 25 Feb 2020 12:52:21 +0000 (UTC) Received: by blackfin.pond.sub.org (Postfix, from userid 1000) id E117711386A6; Tue, 25 Feb 2020 13:52:19 +0100 (CET) From: Markus Armbruster To: Vladimir Sementsov-Ogievskiy Subject: Re: [PATCH v7 03/11] scripts: add coccinelle script to use auto propagated errp References: <20200131130118.1716-1-vsementsov@virtuozzo.com> <20200131130118.1716-4-vsementsov@virtuozzo.com> <87v9nxwulz.fsf@dusky.pond.sub.org> Date: Tue, 25 Feb 2020 13:52:19 +0100 In-Reply-To: (Vladimir Sementsov-Ogievskiy's message of "Tue, 25 Feb 2020 12:08:37 +0300") Message-ID: <87wo8aesn0.fsf@dusky.pond.sub.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/26.3 (gnu/linux) MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] [fuzzy] X-Received-From: 207.211.31.81 X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , Stefano Stabellini , qemu-block@nongnu.org, Paul Durrant , Philippe =?utf-8?Q?Mathieu-Daud=C3=A9?= , Michael Roth , qemu-devel@nongnu.org, Greg Kurz , Gerd Hoffmann , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org, Max Reitz , Laszlo Ersek , Stefan Berger Errors-To: qemu-devel-bounces+qemu-devel=archiver.kernel.org@nongnu.org Sender: "Qemu-devel" Vladimir Sementsov-Ogievskiy writes: > 23.02.2020 11:55, Markus Armbruster wrote: >> Vladimir Sementsov-Ogievskiy writes: >> >>> Script adds ERRP_AUTO_PROPAGATE macro invocation where appropriate and >>> does corresponding changes in code (look for details in >>> include/qapi/error.h) >>> >>> Usage example: >>> spatch --sp-file scripts/coccinelle/auto-propagated-errp.cocci \ >>> --macro-file scripts/cocci-macro-file.h --in-place --no-show-diff \ >>> blockdev-nbd.c qemu-nbd.c {block/nbd*,nbd/*,include/block/nbd*}.[hc] >>> >>> Signed-off-by: Vladimir Sementsov-Ogievskiy >>> --- >>> >>> CC: Eric Blake >>> CC: Kevin Wolf >>> CC: Max Reitz >>> CC: Greg Kurz >>> CC: Stefano Stabellini >>> CC: Anthony Perard >>> CC: Paul Durrant >>> CC: Stefan Hajnoczi >>> CC: "Philippe Mathieu-Daud=C3=A9" >>> CC: Laszlo Ersek >>> CC: Gerd Hoffmann >>> CC: Stefan Berger >>> CC: Markus Armbruster >>> CC: Michael Roth >>> CC: qemu-block@nongnu.org >>> CC: xen-devel@lists.xenproject.org >>> >>> include/qapi/error.h | 3 + >>> scripts/coccinelle/auto-propagated-errp.cocci | 158 +++++++++++++++++= + >>> 2 files changed, 161 insertions(+) >>> create mode 100644 scripts/coccinelle/auto-propagated-errp.cocci >>> >>> diff --git a/include/qapi/error.h b/include/qapi/error.h >>> index b9452d4806..79f8e95214 100644 >>> --- a/include/qapi/error.h >>> +++ b/include/qapi/error.h >>> @@ -141,6 +141,9 @@ >>> * ... >>> * } >>> * >>> + * For mass conversion use script >>> + * scripts/coccinelle/auto-propagated-errp.cocci >>> + * >>> * >>> * Receive and accumulate multiple errors (first one wins): >>> * Error *err =3D NULL, *local_err =3D NULL; >> >> Extra blank line. >> >>> diff --git a/scripts/coccinelle/auto-propagated-errp.cocci b/scripts/co= ccinelle/auto-propagated-errp.cocci >>> new file mode 100644 >>> index 0000000000..fb03c871cb >>> --- /dev/null >>> +++ b/scripts/coccinelle/auto-propagated-errp.cocci >>> @@ -0,0 +1,158 @@ >>> +// Use ERRP_AUTO_PROPAGATE (see include/qapi/error.h) >>> +// >>> +// Copyright (c) 2020 Virtuozzo International GmbH. >>> +// >>> +// This program is free software; you can redistribute it and/or modif= y >>> +// it under the terms of the GNU General Public License as published b= y >>> +// the Free Software Foundation; either version 2 of the License, or >>> +// (at your option) any later version. >>> +// >>> +// This program is distributed in the hope that it will be useful, >>> +// but WITHOUT ANY WARRANTY; without even the implied warranty of >>> +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >>> +// GNU General Public License for more details. >>> +// >>> +// You should have received a copy of the GNU General Public License >>> +// along with this program. If not, see . >>> +// >>> +// Usage example: >>> +// spatch --sp-file scripts/coccinelle/auto-propagated-errp.cocci \ >>> +// --macro-file scripts/cocci-macro-file.h --in-place --no-show-diff = \ >>> +// blockdev-nbd.c qemu-nbd.c {block/nbd*,nbd/*,include/block/nbd*}.[h= c] >>> + >>> +@rule0@ >>> +// Add invocation to errp-functions where necessary >>> +// We should skip functions with "Error *const *errp" >>> +// parameter, but how to do it with coccinelle? >>> +// I don't know, so, I skip them by function name regex. >>> +// It's safe: if we did not skip some functions with >>> +// "Error *const *errp", ERRP_AUTO_PROPAGATE invocation >>> +// will fail to compile, because of const violation. >> >> Not skipping a function we should skip fails to compile. >> >> What about skipping a function we should not skip? > > Then it will not be updated.. Not good but I don't have better solution. > Still, I hope, function called *error_append_*_hint will not return error > through errp pointer. Seems likely. I just dislike inferring behavior from name patterns. Ideally, we recognize the true exceptional pattern instead, i.e. the presence of const. But figuring out how to make Coccinelle do that for us may be more trouble than it's worth. Hmm... Coccinelle matches the parameter even with const due to what it calls "isomorphism". Can I disable it? *Tinker* *tinker* diff --git a/scripts/coccinelle/auto-propagated-errp.cocci b/scripts/coccin= elle/auto-propagated-errp.cocci index fb03c871cb..0c4414bff3 100644 --- a/scripts/coccinelle/auto-propagated-errp.cocci +++ b/scripts/coccinelle/auto-propagated-errp.cocci @@ -20,15 +20,11 @@ // --macro-file scripts/cocci-macro-file.h --in-place --no-show-diff \ // blockdev-nbd.c qemu-nbd.c {block/nbd*,nbd/*,include/block/nbd*}.[hc] =20 -@rule0@ +@rule0 disable optional_qualifier@ // Add invocation to errp-functions where necessary -// We should skip functions with "Error *const *errp" -// parameter, but how to do it with coccinelle? -// I don't know, so, I skip them by function name regex. -// It's safe: if we did not skip some functions with -// "Error *const *errp", ERRP_AUTO_PROPAGATE invocation -// will fail to compile, because of const violation. -identifier fn !~ "error_append_.*_hint"; +// Disable optional_qualifier to skip functions with "Error *const *errp" +// parameter,=20 +identifier fn; identifier local_err, ERRP; @@ Could you verify this results in the same tree-wide change as your version? >>> +identifier fn !~ "error_append_.*_hint"; >>> +identifier local_err, ERRP; >> >> A few of our coccinelle scripts use ALL_CAPS for meta-variables. Most >> don't. Either is fine with me. Mixing the two styles feels a bit >> confusing, though. >> >>> +@@ >>> + >>> + fn(..., Error **ERRP, ...) >>> + { >>> ++ ERRP_AUTO_PROPAGATE(); >>> + <+... >>> + when !=3D ERRP_AUTO_PROPAGATE(); >>> +( >>> + error_append_hint(ERRP, ...); >>> +| >>> + error_prepend(ERRP, ...); >>> +| >>> + Error *local_err =3D NULL; >>> +) >>> + ...+> >>> + } >> >> Misses error_vprepend(). Currently harmless, but as long as we commit >> the script, we better make it as robust as we reasonably can. >> >> The previous patch explains this Coccinelle script's intent: >> >> To achieve these goals, later patches will add invocations >> of this macro at the start of functions with either use >> error_prepend/error_append_hint (solving 1) or which use >> local_err+error_propagate to check errors, switching those >> functions to use *errp instead (solving 2 and 3). >> >> This rule matches "use error_prepend/error_append_hint" directly. It >> appears to use presence of a local Error * variable as proxy for "use >> local_err+error_propagate to check errors". Hmm. >> >> We obviously have such a variable when we use "local_err+error_propagate >> to check errors". But we could also have such variables without use of >> error_propagate(). In fact, error.h documents such use: >> >> * Call a function and receive an error from it: >> * Error *err =3D NULL; >> * foo(arg, &err); >> * if (err) { >> * handle the error... >> * } >> >> where "handle the error" frees it. >> >> I figure such uses typically occur in functions without an Error **errp >> parameter. This rule doesn't apply then. But they could occur even in >> functions with such a parameter. Consider: >> >> void foo(Error **errp) >> { >> Error *err =3D NULL; >> >> bar(&err); >> if (err) { >> error_free(err); >> error_setg(errp, "completely different error"); >> } >> } >> >> Reasonable enough when bar() gives us an error that's misleading in this >> context, isn't it? >> >> The script transforms it like this: >> >> void foo(Error **errp) >> { >> - Error *err =3D NULL; >> + ERRP_AUTO_PROPAGATE(); >> >> - bar(&err); >> - if (err) { >> - error_free(err); >> + bar(errp); >> + if (*errp) { >> + error_free_errp(errp); >> error_setg(errp, "completely different error"); >> } >> } >> >> Unwanted. > > What is the problem with it? Updated code just use "new usual notation" > for handling error of sub-calls in function which reports errors through > errp pointer. error.h's big comment asks for use of ERRP_AUTO_PROPAGATE() to "Receive an error and pass it on to the caller". We're not doing that here. We "Call a function and receive an error from it", then "Handle an error without reporting it". The updated code works anyway, but it's needlessly complicated. >> Now, if this script applied in just a few dozen places, we could rely on >> eyeballing its output to catch unwanted transformations. Since it >> applies in so many more, I don't feel comfortable relying on reviewer >> eyeballs. >> >> Can we make rule0 directly match error_propagate(errp, local_err) >> somehow? > > I think it is possible, still I'm not sure we need it. We don't need it in the sense of "must have to avoid a buggy transformation". It's more like "I'd like to have it to stay close to the documented usage of ERRP_AUTO_PROPAGATE(), and to avoid complicating cases like the one above". >> Another observation: the rule does not match error_reportf_err() and >> warn_reportf_err(). These combine error_prepend(), >> error_report()/warn_report() and error_free(), for convenience. Don't >> their users need ERRP_AUTO_PROPAGATE() just like error_prepend()'s >> users? > > Right. These functions want to add information, which will not work > for error_fatal without wrapping. A simple improvement, I hope. >>> + >>> +@@ >>> +// Switch unusual (Error **) parameter names to errp >>> +// (this is necessary to use ERRP_AUTO_PROPAGATE). >> >> Please put your rule comments right before the rule, i.e. before the >> @-line introducing metavariable declarations, not after. Same >> elsewhere. >> >>> +identifier rule0.fn; >>> +identifier rule0.ERRP !=3D errp; >>> +@@ >>> + >>> + fn(..., >>> +- Error **ERRP >>> ++ Error **errp >>> + ,...) >>> + { >>> + <... >>> +- ERRP >>> ++ errp >>> + ...> >>> + } >> >> This normalizes errp parameter naming. It matches exactly when rule0 >> matches (and inserts ERRP_AUTO_PROPAGATE()) and the Error ** parameter >> is unusual. Good. >> >>> + >>> +@rule1@ >>> +// We want to patch error propagation in functions regardless of >>> +// whether the function already uses ERRP_AUTO_PROPAGATE prior to >>> +// applying rule0, hence this one does not inherit from it. >> >> I'm not sure I get this comment. Let's see what the rule does. >> >>> +identifier fn !~ "error_append_.*_hint"; >>> +identifier local_err; >>> +symbol errp; >>> +@@ >>> + >>> + fn(..., Error **errp, ...) >>> + { >>> + <... >>> +- Error *local_err =3D NULL; >>> + ...> >>> + } >> >> rule1 matches like rule0, except the Error ** parameter match is >> tightened from any C identifier to the C identifier errp, and the >> function body match tightened from "either use >> error_prepend/error_append_hint or which use local_err+error_propagate >> to check errors" to just the latter. >> >> I figure tightening the Error ** parameter match has no effect, because >> we already normalized the parameter name. >> >> So rule1 deletes variable local_err where rule0 applied. Correct? > > The difference with rule0 is that rule0 contains > "when !=3D ERRP_AUTO_PROPAGATE()", so rule0 is not applied where > we already have macro invocation. Ah, I missed the when clause. > This is why we can't inherit from rule0. > > No we believe that we have ERRP_AUTO_PROPAGATE invocation in all > corresponding places (added by rule0 or before script run) and want to > update all usage of local_err objects. Let's see whether I got it: * The first rule (rule0) adds ERRP_AUTO_PROPAGATE() to all functions that take an Error ** parameter, and either pass it error_prepend() or error_append_hint(), or use local_err, and don't have ERRP_AUTO_PROPAGATE() already, except it skips the ones named error_append_FOO_hint(). Uff. The "use local_err" part is an approximation of "use local_err + error_propagate()". The "except for the ones named error_append_FOO_hint()" part is an approximation of "except for the ones taking an Error *const * parameter". ERRP_AUTO_PROPAGATE() requires the Error ** parameter to be named @errp, which need not be the case. The next rule fixes it up: * The second rule ensures the parameter is named @errp wherever the first rule applied, renaming if necessary. Correct? Incorrect transformation followed by fixup is not ideal, because it can trip up reviewers. But ideal is too expensive; this is good enough. * The third rule (rule1) ensures functions that take an Error **errp parameter don't declare local_err, except it skips the ones named error_append_FOO_hint(). In isolation, this rule makes no sense. To make sense of it, we need context: * Subsequent rules remove all uses of @errp from any function where rule1 matches. * Preceding rules ensure any function where rule1 matches has ERRP_AUTO_PROPAGATE(). Correct? The need for this much context is hard on reviewers. Good enough for transforming the tree now, but I'd hate having to make sense of this again in six months. >>> + >>> +@@ >>> +// Handle pattern with goto, otherwise we'll finish up >>> +// with labels at function end which will not compile. >>> +identifier rule1.fn, rule1.local_err; >>> +identifier OUT; >>> +@@ >>> + >>> + fn(...) >>> + { >>> + <... >>> +- goto OUT; >>> ++ return; >>> + ...> >>> +- OUT: >>> +- error_propagate(errp, local_err); >>> + } >> >> This is one special case of error_propagate() deletion. It additionally >> gets rid of a goto we no longer want. For the general case, see below. >> >> The rule applies only where rule1 just deleted the variable. Thus, the >> two rules work in tandem. Makes sense. >> >>> + >>> +@@ >>> +identifier rule1.fn, rule1.local_err; >> >> This rule also works in tandem with rule1. >> >>> +expression list args; // to reindent error_propagate_prepend >> >> What is the comment trying to tell me? > > Hmm, we can safely drop it. It's about the following: > > instead of > > - error_propagate_prepend(errp, local_err, args); > + error_prepend(errp, args); > > we can use "...", like > > - error_propagate_prepend(errp, local_err > + error_prepend(errp > , ...); > > but with metavar in use, coccinelle will correctly reindent the > whole call, which looks a lot better. Let's drop the comment. >>> +@@ >>> + >>> + fn(...) >>> + { >>> + <... >>> +( >>> +- error_free(local_err); >>> +- local_err =3D NULL; >>> ++ error_free_errp(errp); >> >> Reminder: >> >> static inline void error_free_errp(Error **errp) >> { >> assert(errp && *errp); >> error_free(*errp); >> *errp =3D NULL; >> } >> >> Now let's examine the actual change. >> >> The assertion's first half trivially holds, ERRP_AUTO_PROPAGATE() >> ensures it. >> >> The second half is new. We now crash when we haven't set an error. Why >> is this safe? Note that error_free(local_err) does nothing when >> !local_err. > > Hmm. Looks like we should tighten this restriction, and follow error_free > interface, which allows freeing unset errp. > >> >> The zapping of the variable pointing to the Error just freed is >> unchanged. >> >>> +| >>> +- error_free(local_err); >>> ++ error_free_errp(errp); >> >> Here, the zapping is new. Zapping dangling pointers is obviously safe. >> Needed, or else the automatic error_propagate() due to >> ERRP_AUTO_PROPAGATE() would propagate the dangling pointer. >> >>> +| >>> +- error_report_err(local_err); >>> ++ error_report_errp(errp); >> >> The only difference to the previous case is that we also report the >> error. >> >> The previous case has a buddy that additionally matches *errp =3D NULL. >> Why not this one? > > Probably because no matches in code. But should be added here for > better case coverage. Either that or a comment pointing out what's missing, and why, namely because the pattern doesn't exist in the tree. >> >>> +| >>> +- warn_report_err(local_err); >>> ++ warn_report_errp(errp); >> >> Likewise. >> >> What about error_reportf_err(), warn_reportf_err()? >> >> Up to here, this rule transforms the various forms of error_free(). >> Next: error_propagate(). >> >>> +| >>> +- error_propagate_prepend(errp, local_err, args); >>> ++ error_prepend(errp, args); >>> +| >>> +- error_propagate(errp, local_err); >> >> rule0's adding of ERRP_AUTO_PROPAGATE() made error_propagate() >> redundant. >> >> This is the general case of error_propagate() deletion. >> >> I'd put the plain error_propagate() first, variations second, like you >> do with error_free(). >> >> If neither of these two patterns match on a path from >> ERRP_AUTO_PROPAGATE() to return, we effectively insert error_propagate() >> where it wasn't before. Does nothing when the local error is null >> there. Bug fix when it isn't: it's at least a memory leak, and quite >> possibly worse. > > Hmm. How can it be memory leak after any of error_free variants? Consider nfs_options_qdict_to_qapi() right before commit 54b7af4369a fixed it: static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *options, Error **errp) { BlockdevOptionsNfs *opts =3D NULL; QObject *crumpled =3D NULL; Visitor *v; Error *local_err =3D NULL; crumpled =3D qdict_crumple(options, errp); if (crumpled =3D=3D NULL) { return NULL; } v =3D qobject_input_visitor_new_keyval(crumpled); visit_type_BlockdevOptionsNfs(v, NULL, &opts, &local_err); visit_free(v); qobject_unref(crumpled); if (local_err) { return NULL; } return opts; } When visit_type_BlockdevOptionsNfs() fails, we return null without setting an error. We also leak the error we got from visit_type_BlockdevOptionsNfs(). Commit 54b7af4369a fixed this: --- a/block/nfs.c +++ b/block/nfs.c @@ -570,6 +570,7 @@ static BlockdevOptionsNfs *nfs_options_qdict_to_qap= i(QDict * options, qobject_unref(crumpled); if (local_err) { + error_propagate(errp, local_err); return NULL; } If it was still broken, then your transformation would *also* fix it, wouldn't it? My point is: your transformation might fix actual bugs! >> Identifying these bug fixes would be nice, but I don't have practical >> ideas on how to do that. >> >> Can we explain this in the commit message? >> >>> +) >>> + ...> >>> + } >>> + >>> +@@ >>> +identifier rule1.fn, rule1.local_err; >>> +@@ >>> + >>> + fn(...) >>> + { >>> + <... >>> +( >>> +- &local_err >>> ++ errp >>> +| >>> +- local_err >>> ++ *errp >>> +) >>> + ...> >>> + } >> >> Also in tandem with rule1, fixes up uses of local_err. Good. >> >>> + >>> +@@ >>> +identifier rule1.fn; >>> +@@ >>> + >>> + fn(...) >>> + { >>> + <... >>> +- *errp !=3D NULL >>> ++ *errp >>> + ...> >>> + } >> >> Still in tandem with rule1, normalizes style. Good. >> From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.6 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7637DC35DF5 for ; Tue, 25 Feb 2020 12:53:05 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 3097A21556 for ; Tue, 25 Feb 2020 12:53:05 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="jE6vi4rb" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 3097A21556 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1j6ZhY-0005AR-2p; Tue, 25 Feb 2020 12:52:40 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1j6ZhX-0005AM-Dq for xen-devel@lists.xenproject.org; Tue, 25 Feb 2020 12:52:39 +0000 X-Inumbo-ID: b318e146-57cd-11ea-a490-bc764e2007e4 Received: from us-smtp-delivery-1.mimecast.com (unknown [207.211.31.120]) by us1-rack-iad1.inumbo.com (Halon) with ESMTP id b318e146-57cd-11ea-a490-bc764e2007e4; Tue, 25 Feb 2020 12:52:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1582635157; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=1H5OPfKRh44KkyAsiRb48VNd1UWqDOE2wt/zeMaIJQc=; b=jE6vi4rbZfC/fDDi9WtTbvmz9gkZfhVSW422RDDwC8HYrfrlRUnYh0k7cl4e1Muzahn0c8 /I0Dj9MzK+UvGuvoR15XW8yiZcNjHRnouS9wcV5KDbShAtYfg6gAPM1LFm+rXGH0BKpzeC X5sXF/U0th55jvTMDQf6mensbLu4htY= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-365-2e9ZiuggOryDCa0mSFpFLw-1; Tue, 25 Feb 2020 07:52:29 -0500 X-MC-Unique: 2e9ZiuggOryDCa0mSFpFLw-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id C5F111005F70; Tue, 25 Feb 2020 12:52:27 +0000 (UTC) Received: from blackfin.pond.sub.org (ovpn-116-129.ams2.redhat.com [10.36.116.129]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 654275C1D6; Tue, 25 Feb 2020 12:52:21 +0000 (UTC) Received: by blackfin.pond.sub.org (Postfix, from userid 1000) id E117711386A6; Tue, 25 Feb 2020 13:52:19 +0100 (CET) From: Markus Armbruster To: Vladimir Sementsov-Ogievskiy References: <20200131130118.1716-1-vsementsov@virtuozzo.com> <20200131130118.1716-4-vsementsov@virtuozzo.com> <87v9nxwulz.fsf@dusky.pond.sub.org> Date: Tue, 25 Feb 2020 13:52:19 +0100 In-Reply-To: (Vladimir Sementsov-Ogievskiy's message of "Tue, 25 Feb 2020 12:08:37 +0300") Message-ID: <87wo8aesn0.fsf@dusky.pond.sub.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/26.3 (gnu/linux) MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Subject: Re: [Xen-devel] [PATCH v7 03/11] scripts: add coccinelle script to use auto propagated errp X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , Stefano Stabellini , qemu-block@nongnu.org, Paul Durrant , Philippe =?utf-8?Q?Mathieu-Daud=C3=A9?= , Michael Roth , qemu-devel@nongnu.org, Greg Kurz , Gerd Hoffmann , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org, Max Reitz , Laszlo Ersek , Stefan Berger Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" VmxhZGltaXIgU2VtZW50c292LU9naWV2c2tpeSA8dnNlbWVudHNvdkB2aXJ0dW96em8uY29tPiB3 cml0ZXM6Cgo+IDIzLjAyLjIwMjAgMTE6NTUsIE1hcmt1cyBBcm1icnVzdGVyIHdyb3RlOgo+PiBW bGFkaW1pciBTZW1lbnRzb3YtT2dpZXZza2l5IDx2c2VtZW50c292QHZpcnR1b3p6by5jb20+IHdy aXRlczoKPj4KPj4+IFNjcmlwdCBhZGRzIEVSUlBfQVVUT19QUk9QQUdBVEUgbWFjcm8gaW52b2Nh dGlvbiB3aGVyZSBhcHByb3ByaWF0ZSBhbmQKPj4+IGRvZXMgY29ycmVzcG9uZGluZyBjaGFuZ2Vz IGluIGNvZGUgKGxvb2sgZm9yIGRldGFpbHMgaW4KPj4+IGluY2x1ZGUvcWFwaS9lcnJvci5oKQo+ Pj4KPj4+IFVzYWdlIGV4YW1wbGU6Cj4+PiBzcGF0Y2ggLS1zcC1maWxlIHNjcmlwdHMvY29jY2lu ZWxsZS9hdXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaSBcCj4+PiAgIC0tbWFjcm8tZmlsZSBzY3Jp cHRzL2NvY2NpLW1hY3JvLWZpbGUuaCAtLWluLXBsYWNlIC0tbm8tc2hvdy1kaWZmIFwKPj4+ICAg YmxvY2tkZXYtbmJkLmMgcWVtdS1uYmQuYyB7YmxvY2svbmJkKixuYmQvKixpbmNsdWRlL2Jsb2Nr L25iZCp9LltoY10KPj4+Cj4+PiBTaWduZWQtb2ZmLWJ5OiBWbGFkaW1pciBTZW1lbnRzb3YtT2dp ZXZza2l5IDx2c2VtZW50c292QHZpcnR1b3p6by5jb20+Cj4+PiAtLS0KPj4+Cj4+PiBDQzogRXJp YyBCbGFrZSA8ZWJsYWtlQHJlZGhhdC5jb20+Cj4+PiBDQzogS2V2aW4gV29sZiA8a3dvbGZAcmVk aGF0LmNvbT4KPj4+IENDOiBNYXggUmVpdHogPG1yZWl0ekByZWRoYXQuY29tPgo+Pj4gQ0M6IEdy ZWcgS3VyeiA8Z3JvdWdAa2FvZC5vcmc+Cj4+PiBDQzogU3RlZmFubyBTdGFiZWxsaW5pIDxzc3Rh YmVsbGluaUBrZXJuZWwub3JnPgo+Pj4gQ0M6IEFudGhvbnkgUGVyYXJkIDxhbnRob255LnBlcmFy ZEBjaXRyaXguY29tPgo+Pj4gQ0M6IFBhdWwgRHVycmFudCA8cGF1bEB4ZW4ub3JnPgo+Pj4gQ0M6 IFN0ZWZhbiBIYWpub2N6aSA8c3RlZmFuaGFAcmVkaGF0LmNvbT4KPj4+IENDOiAiUGhpbGlwcGUg TWF0aGlldS1EYXVkw6kiIDxwaGlsbWRAcmVkaGF0LmNvbT4KPj4+IENDOiBMYXN6bG8gRXJzZWsg PGxlcnNla0ByZWRoYXQuY29tPgo+Pj4gQ0M6IEdlcmQgSG9mZm1hbm4gPGtyYXhlbEByZWRoYXQu Y29tPgo+Pj4gQ0M6IFN0ZWZhbiBCZXJnZXIgPHN0ZWZhbmJAbGludXguaWJtLmNvbT4KPj4+IEND OiBNYXJrdXMgQXJtYnJ1c3RlciA8YXJtYnJ1QHJlZGhhdC5jb20+Cj4+PiBDQzogTWljaGFlbCBS b3RoIDxtZHJvdGhAbGludXgudm5ldC5pYm0uY29tPgo+Pj4gQ0M6IHFlbXUtYmxvY2tAbm9uZ251 Lm9yZwo+Pj4gQ0M6IHhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwo+Pj4KPj4+ICAgaW5j bHVkZS9xYXBpL2Vycm9yLmggICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAzICsKPj4+ICAg c2NyaXB0cy9jb2NjaW5lbGxlL2F1dG8tcHJvcGFnYXRlZC1lcnJwLmNvY2NpIHwgMTU4ICsrKysr KysrKysrKysrKysrKwo+Pj4gICAyIGZpbGVzIGNoYW5nZWQsIDE2MSBpbnNlcnRpb25zKCspCj4+ PiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBzY3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVk LWVycnAuY29jY2kKPj4+Cj4+PiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9xYXBpL2Vycm9yLmggYi9p bmNsdWRlL3FhcGkvZXJyb3IuaAo+Pj4gaW5kZXggYjk0NTJkNDgwNi4uNzlmOGU5NTIxNCAxMDA2 NDQKPj4+IC0tLSBhL2luY2x1ZGUvcWFwaS9lcnJvci5oCj4+PiArKysgYi9pbmNsdWRlL3FhcGkv ZXJyb3IuaAo+Pj4gQEAgLTE0MSw2ICsxNDEsOSBAQAo+Pj4gICAgKiAgICAgICAgIC4uLgo+Pj4g ICAgKiAgICAgfQo+Pj4gICAgKgo+Pj4gKyAqIEZvciBtYXNzIGNvbnZlcnNpb24gdXNlIHNjcmlw dAo+Pj4gKyAqICAgc2NyaXB0cy9jb2NjaW5lbGxlL2F1dG8tcHJvcGFnYXRlZC1lcnJwLmNvY2Np Cj4+PiArICoKPj4+ICAgICoKPj4+ICAgICogUmVjZWl2ZSBhbmQgYWNjdW11bGF0ZSBtdWx0aXBs ZSBlcnJvcnMgKGZpcnN0IG9uZSB3aW5zKToKPj4+ICAgICogICAgIEVycm9yICplcnIgPSBOVUxM LCAqbG9jYWxfZXJyID0gTlVMTDsKPj4KPj4gRXh0cmEgYmxhbmsgbGluZS4KPj4KPj4+IGRpZmYg LS1naXQgYS9zY3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29jY2kgYi9z Y3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29jY2kKPj4+IG5ldyBmaWxl IG1vZGUgMTAwNjQ0Cj4+PiBpbmRleCAwMDAwMDAwMDAwLi5mYjAzYzg3MWNiCj4+PiAtLS0gL2Rl di9udWxsCj4+PiArKysgYi9zY3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAu Y29jY2kKPj4+IEBAIC0wLDAgKzEsMTU4IEBACj4+PiArLy8gVXNlIEVSUlBfQVVUT19QUk9QQUdB VEUgKHNlZSBpbmNsdWRlL3FhcGkvZXJyb3IuaCkKPj4+ICsvLwo+Pj4gKy8vIENvcHlyaWdodCAo YykgMjAyMCBWaXJ0dW96em8gSW50ZXJuYXRpb25hbCBHbWJILgo+Pj4gKy8vCj4+PiArLy8gVGhp cyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9v ciBtb2RpZnkKPj4+ICsvLyBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQo+Pj4gKy8vIHRoZSBGcmVlIFNvZnR3YXJlIEZv dW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCj4+PiArLy8gKGF0 IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KPj4+ICsvLwo+Pj4gKy8vIFRoaXMgcHJv Z3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAo+ Pj4gKy8vIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCj4+PiArLy8gTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQo+Pj4gKy8vIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCj4+PiArLy8KPj4+ICsvLyBZb3Ugc2hvdWxkIGhhdmUgcmVj ZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQo+Pj4gKy8vIGFs b25nIHdpdGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9s aWNlbnNlcy8+Lgo+Pj4gKy8vCj4+PiArLy8gVXNhZ2UgZXhhbXBsZToKPj4+ICsvLyBzcGF0Y2gg LS1zcC1maWxlIHNjcmlwdHMvY29jY2luZWxsZS9hdXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaSBc Cj4+PiArLy8gIC0tbWFjcm8tZmlsZSBzY3JpcHRzL2NvY2NpLW1hY3JvLWZpbGUuaCAtLWluLXBs YWNlIC0tbm8tc2hvdy1kaWZmIFwKPj4+ICsvLyAgYmxvY2tkZXYtbmJkLmMgcWVtdS1uYmQuYyB7 YmxvY2svbmJkKixuYmQvKixpbmNsdWRlL2Jsb2NrL25iZCp9LltoY10KPj4+ICsKPj4+ICtAcnVs ZTBACj4+PiArLy8gQWRkIGludm9jYXRpb24gdG8gZXJycC1mdW5jdGlvbnMgd2hlcmUgbmVjZXNz YXJ5Cj4+PiArLy8gV2Ugc2hvdWxkIHNraXAgZnVuY3Rpb25zIHdpdGggIkVycm9yICpjb25zdCAq ZXJycCIKPj4+ICsvLyBwYXJhbWV0ZXIsIGJ1dCBob3cgdG8gZG8gaXQgd2l0aCBjb2NjaW5lbGxl Pwo+Pj4gKy8vIEkgZG9uJ3Qga25vdywgc28sIEkgc2tpcCB0aGVtIGJ5IGZ1bmN0aW9uIG5hbWUg cmVnZXguCj4+PiArLy8gSXQncyBzYWZlOiBpZiB3ZSBkaWQgbm90IHNraXAgc29tZSBmdW5jdGlv bnMgd2l0aAo+Pj4gKy8vICJFcnJvciAqY29uc3QgKmVycnAiLCBFUlJQX0FVVE9fUFJPUEFHQVRF IGludm9jYXRpb24KPj4+ICsvLyB3aWxsIGZhaWwgdG8gY29tcGlsZSwgYmVjYXVzZSBvZiBjb25z dCB2aW9sYXRpb24uCj4+Cj4+IE5vdCBza2lwcGluZyBhIGZ1bmN0aW9uIHdlIHNob3VsZCBza2lw IGZhaWxzIHRvIGNvbXBpbGUuCj4+Cj4+IFdoYXQgYWJvdXQgc2tpcHBpbmcgYSBmdW5jdGlvbiB3 ZSBzaG91bGQgbm90IHNraXA/Cj4KPiBUaGVuIGl0IHdpbGwgbm90IGJlIHVwZGF0ZWQuLiBOb3Qg Z29vZCBidXQgSSBkb24ndCBoYXZlIGJldHRlciBzb2x1dGlvbi4KPiBTdGlsbCwgSSBob3BlLCBm dW5jdGlvbiBjYWxsZWQgKmVycm9yX2FwcGVuZF8qX2hpbnQgd2lsbCBub3QgcmV0dXJuIGVycm9y Cj4gdGhyb3VnaCBlcnJwIHBvaW50ZXIuCgpTZWVtcyBsaWtlbHkuICBJIGp1c3QgZGlzbGlrZSBp bmZlcnJpbmcgYmVoYXZpb3IgZnJvbSBuYW1lIHBhdHRlcm5zLgoKSWRlYWxseSwgd2UgcmVjb2du aXplIHRoZSB0cnVlIGV4Y2VwdGlvbmFsIHBhdHRlcm4gaW5zdGVhZCwgaS5lLiB0aGUKcHJlc2Vu Y2Ugb2YgY29uc3QuICBCdXQgZmlndXJpbmcgb3V0IGhvdyB0byBtYWtlIENvY2NpbmVsbGUgZG8g dGhhdCBmb3IKdXMgbWF5IGJlIG1vcmUgdHJvdWJsZSB0aGFuIGl0J3Mgd29ydGguCgpIbW0uLi4g IENvY2NpbmVsbGUgbWF0Y2hlcyB0aGUgcGFyYW1ldGVyIGV2ZW4gd2l0aCBjb25zdCBkdWUgdG8g d2hhdCBpdApjYWxscyAiaXNvbW9ycGhpc20iLiAgQ2FuIEkgZGlzYWJsZSBpdD8gICpUaW5rZXIq ICp0aW5rZXIqCgpkaWZmIC0tZ2l0IGEvc2NyaXB0cy9jb2NjaW5lbGxlL2F1dG8tcHJvcGFnYXRl ZC1lcnJwLmNvY2NpIGIvc2NyaXB0cy9jb2NjaW5lbGxlL2F1dG8tcHJvcGFnYXRlZC1lcnJwLmNv Y2NpCmluZGV4IGZiMDNjODcxY2IuLjBjNDQxNGJmZjMgMTAwNjQ0Ci0tLSBhL3NjcmlwdHMvY29j Y2luZWxsZS9hdXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaQorKysgYi9zY3JpcHRzL2NvY2NpbmVs bGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29jY2kKQEAgLTIwLDE1ICsyMCwxMSBAQAogLy8gIC0t bWFjcm8tZmlsZSBzY3JpcHRzL2NvY2NpLW1hY3JvLWZpbGUuaCAtLWluLXBsYWNlIC0tbm8tc2hv dy1kaWZmIFwKIC8vICBibG9ja2Rldi1uYmQuYyBxZW11LW5iZC5jIHtibG9jay9uYmQqLG5iZC8q LGluY2x1ZGUvYmxvY2svbmJkKn0uW2hjXQogCi1AcnVsZTBACitAcnVsZTAgZGlzYWJsZSBvcHRp b25hbF9xdWFsaWZpZXJACiAvLyBBZGQgaW52b2NhdGlvbiB0byBlcnJwLWZ1bmN0aW9ucyB3aGVy ZSBuZWNlc3NhcnkKLS8vIFdlIHNob3VsZCBza2lwIGZ1bmN0aW9ucyB3aXRoICJFcnJvciAqY29u c3QgKmVycnAiCi0vLyBwYXJhbWV0ZXIsIGJ1dCBob3cgdG8gZG8gaXQgd2l0aCBjb2NjaW5lbGxl PwotLy8gSSBkb24ndCBrbm93LCBzbywgSSBza2lwIHRoZW0gYnkgZnVuY3Rpb24gbmFtZSByZWdl eC4KLS8vIEl0J3Mgc2FmZTogaWYgd2UgZGlkIG5vdCBza2lwIHNvbWUgZnVuY3Rpb25zIHdpdGgK LS8vICJFcnJvciAqY29uc3QgKmVycnAiLCBFUlJQX0FVVE9fUFJPUEFHQVRFIGludm9jYXRpb24K LS8vIHdpbGwgZmFpbCB0byBjb21waWxlLCBiZWNhdXNlIG9mIGNvbnN0IHZpb2xhdGlvbi4KLWlk ZW50aWZpZXIgZm4gIX4gImVycm9yX2FwcGVuZF8uKl9oaW50IjsKKy8vIERpc2FibGUgb3B0aW9u YWxfcXVhbGlmaWVyIHRvIHNraXAgZnVuY3Rpb25zIHdpdGggIkVycm9yICpjb25zdCAqZXJycCIK Ky8vIHBhcmFtZXRlciwgCitpZGVudGlmaWVyIGZuOwogaWRlbnRpZmllciBsb2NhbF9lcnIsIEVS UlA7CiBAQAoKQ291bGQgeW91IHZlcmlmeSB0aGlzIHJlc3VsdHMgaW4gdGhlIHNhbWUgdHJlZS13 aWRlIGNoYW5nZSBhcyB5b3VyCnZlcnNpb24/Cgo+Pj4gK2lkZW50aWZpZXIgZm4gIX4gImVycm9y X2FwcGVuZF8uKl9oaW50IjsKPj4+ICtpZGVudGlmaWVyIGxvY2FsX2VyciwgRVJSUDsKPj4KPj4g QSBmZXcgb2Ygb3VyIGNvY2NpbmVsbGUgc2NyaXB0cyB1c2UgQUxMX0NBUFMgZm9yIG1ldGEtdmFy aWFibGVzLiAgTW9zdAo+PiBkb24ndC4gIEVpdGhlciBpcyBmaW5lIHdpdGggbWUuICBNaXhpbmcg dGhlIHR3byBzdHlsZXMgZmVlbHMgYSBiaXQKPj4gY29uZnVzaW5nLCB0aG91Z2guCj4+Cj4+PiAr QEAKPj4+ICsKPj4+ICsgZm4oLi4uLCBFcnJvciAqKkVSUlAsIC4uLikKPj4+ICsgewo+Pj4gKysg ICBFUlJQX0FVVE9fUFJPUEFHQVRFKCk7Cj4+PiArICAgIDwrLi4uCj4+PiArICAgICAgICB3aGVu ICE9IEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKPj4+ICsoCj4+PiArICAgIGVycm9yX2FwcGVuZF9o aW50KEVSUlAsIC4uLik7Cj4+PiArfAo+Pj4gKyAgICBlcnJvcl9wcmVwZW5kKEVSUlAsIC4uLik7 Cj4+PiArfAo+Pj4gKyAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKPj4+ICspCj4+PiArICAg IC4uLis+Cj4+PiArIH0KPj4KPj4gTWlzc2VzIGVycm9yX3ZwcmVwZW5kKCkuICBDdXJyZW50bHkg aGFybWxlc3MsIGJ1dCBhcyBsb25nIGFzIHdlIGNvbW1pdAo+PiB0aGUgc2NyaXB0LCB3ZSBiZXR0 ZXIgbWFrZSBpdCBhcyByb2J1c3QgYXMgd2UgcmVhc29uYWJseSBjYW4uCj4+Cj4+IFRoZSBwcmV2 aW91cyBwYXRjaCBleHBsYWlucyB0aGlzIENvY2NpbmVsbGUgc2NyaXB0J3MgaW50ZW50Ogo+Pgo+ PiAgICBUbyBhY2hpZXZlIHRoZXNlIGdvYWxzLCBsYXRlciBwYXRjaGVzIHdpbGwgYWRkIGludm9j YXRpb25zCj4+ICAgIG9mIHRoaXMgbWFjcm8gYXQgdGhlIHN0YXJ0IG9mIGZ1bmN0aW9ucyB3aXRo IGVpdGhlciB1c2UKPj4gICAgZXJyb3JfcHJlcGVuZC9lcnJvcl9hcHBlbmRfaGludCAoc29sdmlu ZyAxKSBvciB3aGljaCB1c2UKPj4gICAgbG9jYWxfZXJyK2Vycm9yX3Byb3BhZ2F0ZSB0byBjaGVj ayBlcnJvcnMsIHN3aXRjaGluZyB0aG9zZQo+PiAgICBmdW5jdGlvbnMgdG8gdXNlICplcnJwIGlu c3RlYWQgKHNvbHZpbmcgMiBhbmQgMykuCj4+Cj4+IFRoaXMgcnVsZSBtYXRjaGVzICJ1c2UgZXJy b3JfcHJlcGVuZC9lcnJvcl9hcHBlbmRfaGludCIgZGlyZWN0bHkuICBJdAo+PiBhcHBlYXJzIHRv IHVzZSBwcmVzZW5jZSBvZiBhIGxvY2FsIEVycm9yICogdmFyaWFibGUgYXMgcHJveHkgZm9yICJ1 c2UKPj4gbG9jYWxfZXJyK2Vycm9yX3Byb3BhZ2F0ZSB0byBjaGVjayBlcnJvcnMiLiAgSG1tLgo+ Pgo+PiBXZSBvYnZpb3VzbHkgaGF2ZSBzdWNoIGEgdmFyaWFibGUgd2hlbiB3ZSB1c2UgImxvY2Fs X2VycitlcnJvcl9wcm9wYWdhdGUKPj4gdG8gY2hlY2sgZXJyb3JzIi4gIEJ1dCB3ZSBjb3VsZCBh bHNvIGhhdmUgc3VjaCB2YXJpYWJsZXMgd2l0aG91dCB1c2Ugb2YKPj4gZXJyb3JfcHJvcGFnYXRl KCkuICBJbiBmYWN0LCBlcnJvci5oIGRvY3VtZW50cyBzdWNoIHVzZToKPj4KPj4gICAqIENhbGwg YSBmdW5jdGlvbiBhbmQgcmVjZWl2ZSBhbiBlcnJvciBmcm9tIGl0Ogo+PiAgICogICAgIEVycm9y ICplcnIgPSBOVUxMOwo+PiAgICogICAgIGZvbyhhcmcsICZlcnIpOwo+PiAgICogICAgIGlmIChl cnIpIHsKPj4gICAqICAgICAgICAgaGFuZGxlIHRoZSBlcnJvci4uLgo+PiAgICogICAgIH0KPj4K Pj4gd2hlcmUgImhhbmRsZSB0aGUgZXJyb3IiIGZyZWVzIGl0Lgo+Pgo+PiBJIGZpZ3VyZSBzdWNo IHVzZXMgdHlwaWNhbGx5IG9jY3VyIGluIGZ1bmN0aW9ucyB3aXRob3V0IGFuIEVycm9yICoqZXJy cAo+PiBwYXJhbWV0ZXIuICBUaGlzIHJ1bGUgZG9lc24ndCBhcHBseSB0aGVuLiAgQnV0IHRoZXkg Y291bGQgb2NjdXIgZXZlbiBpbgo+PiBmdW5jdGlvbnMgd2l0aCBzdWNoIGEgcGFyYW1ldGVyLiAg Q29uc2lkZXI6Cj4+Cj4+ICAgICAgdm9pZCBmb28oRXJyb3IgKiplcnJwKQo+PiAgICAgIHsKPj4g ICAgICAgICAgRXJyb3IgKmVyciA9IE5VTEw7Cj4+Cj4+ICAgICAgICAgIGJhcigmZXJyKTsKPj4g ICAgICAgICAgaWYgKGVycikgewo+PiAgICAgICAgICAgICAgZXJyb3JfZnJlZShlcnIpOwo+PiAg ICAgICAgICAgICAgZXJyb3Jfc2V0ZyhlcnJwLCAiY29tcGxldGVseSBkaWZmZXJlbnQgZXJyb3Ii KTsKPj4gICAgICAgICAgfQo+PiAgICAgIH0KPj4KPj4gUmVhc29uYWJsZSBlbm91Z2ggd2hlbiBi YXIoKSBnaXZlcyB1cyBhbiBlcnJvciB0aGF0J3MgbWlzbGVhZGluZyBpbiB0aGlzCj4+IGNvbnRl eHQsIGlzbid0IGl0Pwo+Pgo+PiBUaGUgc2NyaXB0IHRyYW5zZm9ybXMgaXQgbGlrZSB0aGlzOgo+ Pgo+PiAgICAgIHZvaWQgZm9vKEVycm9yICoqZXJycCkKPj4gICAgICB7Cj4+ICAgICAtICAgIEVy cm9yICplcnIgPSBOVUxMOwo+PiAgICAgKyAgICBFUlJQX0FVVE9fUFJPUEFHQVRFKCk7Cj4+Cj4+ ICAgICAtICAgIGJhcigmZXJyKTsKPj4gICAgIC0gICAgaWYgKGVycikgewo+PiAgICAgLSAgICAg ICAgZXJyb3JfZnJlZShlcnIpOwo+PiAgICAgKyAgICBiYXIoZXJycCk7Cj4+ICAgICArICAgIGlm ICgqZXJycCkgewo+PiAgICAgKyAgICAgICAgZXJyb3JfZnJlZV9lcnJwKGVycnApOwo+PiAgICAg ICAgICAgICAgZXJyb3Jfc2V0ZyhlcnJwLCAiY29tcGxldGVseSBkaWZmZXJlbnQgZXJyb3IiKTsK Pj4gICAgICAgICAgfQo+PiAgICAgIH0KPj4KPj4gVW53YW50ZWQuCj4KPiBXaGF0IGlzIHRoZSBw cm9ibGVtIHdpdGggaXQ/IFVwZGF0ZWQgY29kZSBqdXN0IHVzZSAibmV3IHVzdWFsIG5vdGF0aW9u Igo+IGZvciBoYW5kbGluZyBlcnJvciBvZiBzdWItY2FsbHMgaW4gZnVuY3Rpb24gd2hpY2ggcmVw b3J0cyBlcnJvcnMgdGhyb3VnaAo+IGVycnAgcG9pbnRlci4KCmVycm9yLmgncyBiaWcgY29tbWVu dCBhc2tzIGZvciB1c2Ugb2YgRVJSUF9BVVRPX1BST1BBR0FURSgpIHRvICJSZWNlaXZlCmFuIGVy cm9yIGFuZCBwYXNzIGl0IG9uIHRvIHRoZSBjYWxsZXIiLiAgV2UncmUgbm90IGRvaW5nIHRoYXQg aGVyZS4gIFdlCiJDYWxsIGEgZnVuY3Rpb24gYW5kIHJlY2VpdmUgYW4gZXJyb3IgZnJvbSBpdCIs IHRoZW4gIkhhbmRsZSBhbiBlcnJvcgp3aXRob3V0IHJlcG9ydGluZyBpdCIuCgpUaGUgdXBkYXRl ZCBjb2RlIHdvcmtzIGFueXdheSwgYnV0IGl0J3MgbmVlZGxlc3NseSBjb21wbGljYXRlZC4KCj4+ IE5vdywgaWYgdGhpcyBzY3JpcHQgYXBwbGllZCBpbiBqdXN0IGEgZmV3IGRvemVuIHBsYWNlcywg d2UgY291bGQgcmVseSBvbgo+PiBleWViYWxsaW5nIGl0cyBvdXRwdXQgdG8gY2F0Y2ggdW53YW50 ZWQgdHJhbnNmb3JtYXRpb25zLiAgU2luY2UgaXQKPj4gYXBwbGllcyBpbiBzbyBtYW55IG1vcmUs IEkgZG9uJ3QgZmVlbCBjb21mb3J0YWJsZSByZWx5aW5nIG9uIHJldmlld2VyCj4+IGV5ZWJhbGxz Lgo+Pgo+PiBDYW4gd2UgbWFrZSBydWxlMCBkaXJlY3RseSBtYXRjaCBlcnJvcl9wcm9wYWdhdGUo ZXJycCwgbG9jYWxfZXJyKQo+PiBzb21laG93Pwo+Cj4gSSB0aGluayBpdCBpcyBwb3NzaWJsZSwg c3RpbGwgSSdtIG5vdCBzdXJlIHdlIG5lZWQgaXQuCgpXZSBkb24ndCBuZWVkIGl0IGluIHRoZSBz ZW5zZSBvZiAibXVzdCBoYXZlIHRvIGF2b2lkIGEgYnVnZ3kKdHJhbnNmb3JtYXRpb24iLiAgSXQn cyBtb3JlIGxpa2UgIkknZCBsaWtlIHRvIGhhdmUgaXQgdG8gc3RheSBjbG9zZSB0bwp0aGUgZG9j dW1lbnRlZCB1c2FnZSBvZiBFUlJQX0FVVE9fUFJPUEFHQVRFKCksIGFuZCB0byBhdm9pZCBjb21w bGljYXRpbmcKY2FzZXMgbGlrZSB0aGUgb25lIGFib3ZlIi4KCj4+IEFub3RoZXIgb2JzZXJ2YXRp b246IHRoZSBydWxlIGRvZXMgbm90IG1hdGNoIGVycm9yX3JlcG9ydGZfZXJyKCkgYW5kCj4+IHdh cm5fcmVwb3J0Zl9lcnIoKS4gIFRoZXNlIGNvbWJpbmUgZXJyb3JfcHJlcGVuZCgpLAo+PiBlcnJv cl9yZXBvcnQoKS93YXJuX3JlcG9ydCgpIGFuZCBlcnJvcl9mcmVlKCksIGZvciBjb252ZW5pZW5j ZS4gIERvbid0Cj4+IHRoZWlyIHVzZXJzIG5lZWQgRVJSUF9BVVRPX1BST1BBR0FURSgpIGp1c3Qg bGlrZSBlcnJvcl9wcmVwZW5kKCkncwo+PiB1c2Vycz8KPgo+IFJpZ2h0LiBUaGVzZSBmdW5jdGlv bnMgd2FudCB0byBhZGQgaW5mb3JtYXRpb24sIHdoaWNoIHdpbGwgbm90IHdvcmsKPiBmb3IgZXJy b3JfZmF0YWwgd2l0aG91dCB3cmFwcGluZy4KCkEgc2ltcGxlIGltcHJvdmVtZW50LCBJIGhvcGUu Cgo+Pj4gKwo+Pj4gK0BACj4+PiArLy8gU3dpdGNoIHVudXN1YWwgKEVycm9yICoqKSBwYXJhbWV0 ZXIgbmFtZXMgdG8gZXJycAo+Pj4gKy8vICh0aGlzIGlzIG5lY2Vzc2FyeSB0byB1c2UgRVJSUF9B VVRPX1BST1BBR0FURSkuCj4+Cj4+IFBsZWFzZSBwdXQgeW91ciBydWxlIGNvbW1lbnRzIHJpZ2h0 IGJlZm9yZSB0aGUgcnVsZSwgaS5lLiBiZWZvcmUgdGhlCj4+IEAtbGluZSBpbnRyb2R1Y2luZyBt ZXRhdmFyaWFibGUgZGVjbGFyYXRpb25zLCBub3QgYWZ0ZXIuICBTYW1lCj4+IGVsc2V3aGVyZS4K Pj4KPj4+ICtpZGVudGlmaWVyIHJ1bGUwLmZuOwo+Pj4gK2lkZW50aWZpZXIgcnVsZTAuRVJSUCAh PSBlcnJwOwo+Pj4gK0BACj4+PiArCj4+PiArIGZuKC4uLiwKPj4+ICstICAgRXJyb3IgKipFUlJQ Cj4+PiArKyAgIEVycm9yICoqZXJycAo+Pj4gKyAgICAsLi4uKQo+Pj4gKyB7Cj4+PiArICAgICA8 Li4uCj4+PiArLSAgICBFUlJQCj4+PiArKyAgICBlcnJwCj4+PiArICAgICAuLi4+Cj4+PiArIH0K Pj4KPj4gVGhpcyBub3JtYWxpemVzIGVycnAgcGFyYW1ldGVyIG5hbWluZy4gIEl0IG1hdGNoZXMg ZXhhY3RseSB3aGVuIHJ1bGUwCj4+IG1hdGNoZXMgKGFuZCBpbnNlcnRzIEVSUlBfQVVUT19QUk9Q QUdBVEUoKSkgYW5kIHRoZSBFcnJvciAqKiBwYXJhbWV0ZXIKPj4gaXMgdW51c3VhbC4gIEdvb2Qu Cj4+Cj4+PiArCj4+PiArQHJ1bGUxQAo+Pj4gKy8vIFdlIHdhbnQgdG8gcGF0Y2ggZXJyb3IgcHJv cGFnYXRpb24gaW4gZnVuY3Rpb25zIHJlZ2FyZGxlc3Mgb2YKPj4+ICsvLyB3aGV0aGVyIHRoZSBm dW5jdGlvbiBhbHJlYWR5IHVzZXMgRVJSUF9BVVRPX1BST1BBR0FURSBwcmlvciB0bwo+Pj4gKy8v IGFwcGx5aW5nIHJ1bGUwLCBoZW5jZSB0aGlzIG9uZSBkb2VzIG5vdCBpbmhlcml0IGZyb20gaXQu Cj4+Cj4+IEknbSBub3Qgc3VyZSBJIGdldCB0aGlzIGNvbW1lbnQuICBMZXQncyBzZWUgd2hhdCB0 aGUgcnVsZSBkb2VzLgo+Pgo+Pj4gK2lkZW50aWZpZXIgZm4gIX4gImVycm9yX2FwcGVuZF8uKl9o aW50IjsKPj4+ICtpZGVudGlmaWVyIGxvY2FsX2VycjsKPj4+ICtzeW1ib2wgZXJycDsKPj4+ICtA QAo+Pj4gKwo+Pj4gKyBmbiguLi4sIEVycm9yICoqZXJycCwgLi4uKQo+Pj4gKyB7Cj4+PiArICAg ICA8Li4uCj4+PiArLSAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKPj4+ICsgICAgIC4uLj4K Pj4+ICsgfQo+Pgo+PiBydWxlMSBtYXRjaGVzIGxpa2UgcnVsZTAsIGV4Y2VwdCB0aGUgRXJyb3Ig KiogcGFyYW1ldGVyIG1hdGNoIGlzCj4+IHRpZ2h0ZW5lZCBmcm9tIGFueSBDIGlkZW50aWZpZXIg dG8gdGhlIEMgaWRlbnRpZmllciBlcnJwLCBhbmQgdGhlCj4+IGZ1bmN0aW9uIGJvZHkgbWF0Y2gg dGlnaHRlbmVkIGZyb20gImVpdGhlciB1c2UKPj4gZXJyb3JfcHJlcGVuZC9lcnJvcl9hcHBlbmRf aGludCBvciB3aGljaCB1c2UgbG9jYWxfZXJyK2Vycm9yX3Byb3BhZ2F0ZQo+PiB0byBjaGVjayBl cnJvcnMiIHRvIGp1c3QgdGhlIGxhdHRlci4KPj4KPj4gSSBmaWd1cmUgdGlnaHRlbmluZyB0aGUg RXJyb3IgKiogcGFyYW1ldGVyIG1hdGNoIGhhcyBubyBlZmZlY3QsIGJlY2F1c2UKPj4gd2UgYWxy ZWFkeSBub3JtYWxpemVkIHRoZSBwYXJhbWV0ZXIgbmFtZS4KPj4KPj4gU28gcnVsZTEgZGVsZXRl cyB2YXJpYWJsZSBsb2NhbF9lcnIgd2hlcmUgcnVsZTAgYXBwbGllZC4gIENvcnJlY3Q/Cj4KPiBU aGUgZGlmZmVyZW5jZSB3aXRoIHJ1bGUwIGlzIHRoYXQgcnVsZTAgY29udGFpbnMKPiAgIndoZW4g IT0gRVJSUF9BVVRPX1BST1BBR0FURSgpIiwgc28gcnVsZTAgaXMgbm90IGFwcGxpZWQgd2hlcmUK PiB3ZSBhbHJlYWR5IGhhdmUgbWFjcm8gaW52b2NhdGlvbi4KCkFoLCBJIG1pc3NlZCB0aGUgd2hl biBjbGF1c2UuCgo+IFRoaXMgaXMgd2h5IHdlIGNhbid0IGluaGVyaXQgZnJvbSBydWxlMC4KPgo+ IE5vIHdlIGJlbGlldmUgdGhhdCB3ZSBoYXZlIEVSUlBfQVVUT19QUk9QQUdBVEUgaW52b2NhdGlv biBpbiBhbGwKPiBjb3JyZXNwb25kaW5nIHBsYWNlcyAoYWRkZWQgYnkgcnVsZTAgb3IgYmVmb3Jl IHNjcmlwdCBydW4pIGFuZCB3YW50IHRvCj4gdXBkYXRlIGFsbCB1c2FnZSBvZiBsb2NhbF9lcnIg b2JqZWN0cy4KCkxldCdzIHNlZSB3aGV0aGVyIEkgZ290IGl0OgoKKiBUaGUgZmlyc3QgcnVsZSAo cnVsZTApIGFkZHMgRVJSUF9BVVRPX1BST1BBR0FURSgpIHRvIGFsbCBmdW5jdGlvbnMKICB0aGF0 IHRha2UgYW4gRXJyb3IgKiogcGFyYW1ldGVyLCBhbmQgZWl0aGVyIHBhc3MgaXQgZXJyb3JfcHJl cGVuZCgpIG9yCiAgZXJyb3JfYXBwZW5kX2hpbnQoKSwgb3IgdXNlIGxvY2FsX2VyciwgYW5kIGRv bid0IGhhdmUKICBFUlJQX0FVVE9fUFJPUEFHQVRFKCkgYWxyZWFkeSwgZXhjZXB0IGl0IHNraXBz IHRoZSBvbmVzIG5hbWVkCiAgZXJyb3JfYXBwZW5kX0ZPT19oaW50KCkuICBVZmYuCgogIFRoZSAi dXNlIGxvY2FsX2VyciIgcGFydCBpcyBhbiBhcHByb3hpbWF0aW9uIG9mICJ1c2UgbG9jYWxfZXJy ICsKICBlcnJvcl9wcm9wYWdhdGUoKSIuCgogIFRoZSAiZXhjZXB0IGZvciB0aGUgb25lcyBuYW1l ZCBlcnJvcl9hcHBlbmRfRk9PX2hpbnQoKSIgcGFydCBpcyBhbgogIGFwcHJveGltYXRpb24gb2Yg ImV4Y2VwdCBmb3IgdGhlIG9uZXMgdGFraW5nIGFuIEVycm9yICpjb25zdCAqCiAgcGFyYW1ldGVy Ii4KCiAgRVJSUF9BVVRPX1BST1BBR0FURSgpIHJlcXVpcmVzIHRoZSBFcnJvciAqKiBwYXJhbWV0 ZXIgdG8gYmUgbmFtZWQKICBAZXJycCwgd2hpY2ggbmVlZCBub3QgYmUgdGhlIGNhc2UuICBUaGUg bmV4dCBydWxlIGZpeGVzIGl0IHVwOgoKKiBUaGUgc2Vjb25kIHJ1bGUgZW5zdXJlcyB0aGUgcGFy YW1ldGVyIGlzIG5hbWVkIEBlcnJwIHdoZXJldmVyIHRoZQogIGZpcnN0IHJ1bGUgYXBwbGllZCwg cmVuYW1pbmcgaWYgbmVjZXNzYXJ5LgoKICBDb3JyZWN0PwoKICBJbmNvcnJlY3QgdHJhbnNmb3Jt YXRpb24gZm9sbG93ZWQgYnkgZml4dXAgaXMgbm90IGlkZWFsLCBiZWNhdXNlIGl0CiAgY2FuIHRy aXAgdXAgcmV2aWV3ZXJzLiAgQnV0IGlkZWFsIGlzIHRvbyBleHBlbnNpdmU7IHRoaXMgaXMgZ29v ZAogIGVub3VnaC4KCiogVGhlIHRoaXJkIHJ1bGUgKHJ1bGUxKSBlbnN1cmVzIGZ1bmN0aW9ucyB0 aGF0IHRha2UgYW4gRXJyb3IgKiplcnJwCiAgcGFyYW1ldGVyIGRvbid0IGRlY2xhcmUgbG9jYWxf ZXJyLCBleGNlcHQgaXQgc2tpcHMgdGhlIG9uZXMgbmFtZWQKICBlcnJvcl9hcHBlbmRfRk9PX2hp bnQoKS4KCiAgSW4gaXNvbGF0aW9uLCB0aGlzIHJ1bGUgbWFrZXMgbm8gc2Vuc2UuICBUbyBtYWtl IHNlbnNlIG9mIGl0LCB3ZSBuZWVkCiAgY29udGV4dDoKCiAgKiBTdWJzZXF1ZW50IHJ1bGVzIHJl bW92ZSBhbGwgdXNlcyBvZiBAZXJycCBmcm9tIGFueSBmdW5jdGlvbiB3aGVyZQogICAgcnVsZTEg bWF0Y2hlcy4KCiAgKiBQcmVjZWRpbmcgcnVsZXMgZW5zdXJlIGFueSBmdW5jdGlvbiB3aGVyZSBy dWxlMSBtYXRjaGVzIGhhcwogICAgRVJSUF9BVVRPX1BST1BBR0FURSgpLgoKICBDb3JyZWN0PwoK ICBUaGUgbmVlZCBmb3IgdGhpcyBtdWNoIGNvbnRleHQgaXMgaGFyZCBvbiByZXZpZXdlcnMuICBH b29kIGVub3VnaCBmb3IKICB0cmFuc2Zvcm1pbmcgdGhlIHRyZWUgbm93LCBidXQgSSdkIGhhdGUg aGF2aW5nIHRvIG1ha2Ugc2Vuc2Ugb2YgdGhpcwogIGFnYWluIGluIHNpeCBtb250aHMuCgo+Pj4g Kwo+Pj4gK0BACj4+PiArLy8gSGFuZGxlIHBhdHRlcm4gd2l0aCBnb3RvLCBvdGhlcndpc2Ugd2Un bGwgZmluaXNoIHVwCj4+PiArLy8gd2l0aCBsYWJlbHMgYXQgZnVuY3Rpb24gZW5kIHdoaWNoIHdp bGwgbm90IGNvbXBpbGUuCj4+PiAraWRlbnRpZmllciBydWxlMS5mbiwgcnVsZTEubG9jYWxfZXJy Owo+Pj4gK2lkZW50aWZpZXIgT1VUOwo+Pj4gK0BACj4+PiArCj4+PiArIGZuKC4uLikKPj4+ICsg ewo+Pj4gKyAgICAgPC4uLgo+Pj4gKy0gICAgZ290byBPVVQ7Cj4+PiArKyAgICByZXR1cm47Cj4+ PiArICAgICAuLi4+Cj4+PiArLSBPVVQ6Cj4+PiArLSAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwg bG9jYWxfZXJyKTsKPj4+ICsgfQo+Pgo+PiBUaGlzIGlzIG9uZSBzcGVjaWFsIGNhc2Ugb2YgZXJy b3JfcHJvcGFnYXRlKCkgZGVsZXRpb24uICBJdCBhZGRpdGlvbmFsbHkKPj4gZ2V0cyByaWQgb2Yg YSBnb3RvIHdlIG5vIGxvbmdlciB3YW50LiAgRm9yIHRoZSBnZW5lcmFsIGNhc2UsIHNlZSBiZWxv dy4KPj4KPj4gVGhlIHJ1bGUgYXBwbGllcyBvbmx5IHdoZXJlIHJ1bGUxIGp1c3QgZGVsZXRlZCB0 aGUgdmFyaWFibGUuICBUaHVzLCB0aGUKPj4gdHdvIHJ1bGVzIHdvcmsgaW4gdGFuZGVtLiAgTWFr ZXMgc2Vuc2UuCj4+Cj4+PiArCj4+PiArQEAKPj4+ICtpZGVudGlmaWVyIHJ1bGUxLmZuLCBydWxl MS5sb2NhbF9lcnI7Cj4+Cj4+IFRoaXMgcnVsZSBhbHNvIHdvcmtzIGluIHRhbmRlbSB3aXRoIHJ1 bGUxLgo+Pgo+Pj4gK2V4cHJlc3Npb24gbGlzdCBhcmdzOyAvLyB0byByZWluZGVudCBlcnJvcl9w cm9wYWdhdGVfcHJlcGVuZAo+Pgo+PiBXaGF0IGlzIHRoZSBjb21tZW50IHRyeWluZyB0byB0ZWxs IG1lPwo+Cj4gSG1tLCB3ZSBjYW4gc2FmZWx5IGRyb3AgaXQuIEl0J3MgYWJvdXQgdGhlIGZvbGxv d2luZzoKPgo+IGluc3RlYWQgb2YKPgo+ICAtICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVy cnAsIGxvY2FsX2VyciwgYXJncyk7Cj4gICsgICAgZXJyb3JfcHJlcGVuZChlcnJwLCBhcmdzKTsK Pgo+IHdlIGNhbiB1c2UgIi4uLiIsIGxpa2UKPgo+ICAtIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5k KGVycnAsIGxvY2FsX2Vycgo+ICArIGVycm9yX3ByZXBlbmQoZXJycAo+ICAgICwgLi4uKTsKPgo+ IGJ1dCB3aXRoIG1ldGF2YXIgaW4gdXNlLCBjb2NjaW5lbGxlIHdpbGwgY29ycmVjdGx5IHJlaW5k ZW50IHRoZQo+IHdob2xlIGNhbGwsIHdoaWNoIGxvb2tzIGEgbG90IGJldHRlci4KCkxldCdzIGRy b3AgdGhlIGNvbW1lbnQuCgo+Pj4gK0BACj4+PiArCj4+PiArIGZuKC4uLikKPj4+ICsgewo+Pj4g KyAgICAgPC4uLgo+Pj4gKygKPj4+ICstICAgIGVycm9yX2ZyZWUobG9jYWxfZXJyKTsKPj4+ICst ICAgIGxvY2FsX2VyciA9IE5VTEw7Cj4+PiArKyAgICBlcnJvcl9mcmVlX2VycnAoZXJycCk7Cj4+ Cj4+IFJlbWluZGVyOgo+Pgo+PiAgICAgIHN0YXRpYyBpbmxpbmUgdm9pZCBlcnJvcl9mcmVlX2Vy cnAoRXJyb3IgKiplcnJwKQo+PiAgICAgIHsKPj4gICAgICAgICAgYXNzZXJ0KGVycnAgJiYgKmVy cnApOwo+PiAgICAgICAgICBlcnJvcl9mcmVlKCplcnJwKTsKPj4gICAgICAgICAgKmVycnAgPSBO VUxMOwo+PiAgICAgIH0KPj4KPj4gTm93IGxldCdzIGV4YW1pbmUgdGhlIGFjdHVhbCBjaGFuZ2Uu Cj4+Cj4+IFRoZSBhc3NlcnRpb24ncyBmaXJzdCBoYWxmIHRyaXZpYWxseSBob2xkcywgRVJSUF9B VVRPX1BST1BBR0FURSgpCj4+IGVuc3VyZXMgaXQuCj4+Cj4+IFRoZSBzZWNvbmQgaGFsZiBpcyBu ZXcuICBXZSBub3cgY3Jhc2ggd2hlbiB3ZSBoYXZlbid0IHNldCBhbiBlcnJvci4gIFdoeQo+PiBp cyB0aGlzIHNhZmU/ICBOb3RlIHRoYXQgZXJyb3JfZnJlZShsb2NhbF9lcnIpIGRvZXMgbm90aGlu ZyB3aGVuCj4+ICFsb2NhbF9lcnIuCj4KPiBIbW0uIExvb2tzIGxpa2Ugd2Ugc2hvdWxkIHRpZ2h0 ZW4gdGhpcyByZXN0cmljdGlvbiwgYW5kIGZvbGxvdyBlcnJvcl9mcmVlCj4gaW50ZXJmYWNlLCB3 aGljaCBhbGxvd3MgZnJlZWluZyB1bnNldCBlcnJwLgo+Cj4+Cj4+IFRoZSB6YXBwaW5nIG9mIHRo ZSB2YXJpYWJsZSBwb2ludGluZyB0byB0aGUgRXJyb3IganVzdCBmcmVlZCBpcwo+PiB1bmNoYW5n ZWQuCj4+Cj4+PiArfAo+Pj4gKy0gICAgZXJyb3JfZnJlZShsb2NhbF9lcnIpOwo+Pj4gKysgICAg ZXJyb3JfZnJlZV9lcnJwKGVycnApOwo+Pgo+PiBIZXJlLCB0aGUgemFwcGluZyBpcyBuZXcuICBa YXBwaW5nIGRhbmdsaW5nIHBvaW50ZXJzIGlzIG9idmlvdXNseSBzYWZlLgo+PiBOZWVkZWQsIG9y IGVsc2UgdGhlIGF1dG9tYXRpYyBlcnJvcl9wcm9wYWdhdGUoKSBkdWUgdG8KPj4gRVJSUF9BVVRP X1BST1BBR0FURSgpIHdvdWxkIHByb3BhZ2F0ZSB0aGUgZGFuZ2xpbmcgcG9pbnRlci4KPj4KPj4+ ICt8Cj4+PiArLSAgICBlcnJvcl9yZXBvcnRfZXJyKGxvY2FsX2Vycik7Cj4+PiArKyAgICBlcnJv cl9yZXBvcnRfZXJycChlcnJwKTsKPj4KPj4gVGhlIG9ubHkgZGlmZmVyZW5jZSB0byB0aGUgcHJl dmlvdXMgY2FzZSBpcyB0aGF0IHdlIGFsc28gcmVwb3J0IHRoZQo+PiBlcnJvci4KPj4KPj4gVGhl IHByZXZpb3VzIGNhc2UgaGFzIGEgYnVkZHkgdGhhdCBhZGRpdGlvbmFsbHkgbWF0Y2hlcyAqZXJy cCA9IE5VTEwuCj4+IFdoeSBub3QgdGhpcyBvbmU/Cj4KPiBQcm9iYWJseSBiZWNhdXNlIG5vIG1h dGNoZXMgaW4gY29kZS4gQnV0IHNob3VsZCBiZSBhZGRlZCBoZXJlIGZvcgo+IGJldHRlciBjYXNl IGNvdmVyYWdlLgoKRWl0aGVyIHRoYXQgb3IgYSBjb21tZW50IHBvaW50aW5nIG91dCB3aGF0J3Mg bWlzc2luZywgYW5kIHdoeSwgbmFtZWx5CmJlY2F1c2UgdGhlIHBhdHRlcm4gZG9lc24ndCBleGlz dCBpbiB0aGUgdHJlZS4KCj4+Cj4+PiArfAo+Pj4gKy0gICAgd2Fybl9yZXBvcnRfZXJyKGxvY2Fs X2Vycik7Cj4+PiArKyAgICB3YXJuX3JlcG9ydF9lcnJwKGVycnApOwo+Pgo+PiBMaWtld2lzZS4K Pj4KPj4gV2hhdCBhYm91dCBlcnJvcl9yZXBvcnRmX2VycigpLCB3YXJuX3JlcG9ydGZfZXJyKCk/ Cj4+Cj4+IFVwIHRvIGhlcmUsIHRoaXMgcnVsZSB0cmFuc2Zvcm1zIHRoZSB2YXJpb3VzIGZvcm1z IG9mIGVycm9yX2ZyZWUoKS4KPj4gTmV4dDogZXJyb3JfcHJvcGFnYXRlKCkuCj4+Cj4+PiArfAo+ Pj4gKy0gICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJycCwgbG9jYWxfZXJyLCBhcmdzKTsK Pj4+ICsrICAgIGVycm9yX3ByZXBlbmQoZXJycCwgYXJncyk7Cj4+PiArfAo+Pj4gKy0gICAgZXJy b3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7Cj4+Cj4+IHJ1bGUwJ3MgYWRkaW5nIG9mIEVS UlBfQVVUT19QUk9QQUdBVEUoKSBtYWRlIGVycm9yX3Byb3BhZ2F0ZSgpCj4+IHJlZHVuZGFudC4K Pj4KPj4gVGhpcyBpcyB0aGUgZ2VuZXJhbCBjYXNlIG9mIGVycm9yX3Byb3BhZ2F0ZSgpIGRlbGV0 aW9uLgo+Pgo+PiBJJ2QgcHV0IHRoZSBwbGFpbiBlcnJvcl9wcm9wYWdhdGUoKSBmaXJzdCwgdmFy aWF0aW9ucyBzZWNvbmQsIGxpa2UgeW91Cj4+IGRvIHdpdGggZXJyb3JfZnJlZSgpLgo+Pgo+PiBJ ZiBuZWl0aGVyIG9mIHRoZXNlIHR3byBwYXR0ZXJucyBtYXRjaCBvbiBhIHBhdGggZnJvbQo+PiBF UlJQX0FVVE9fUFJPUEFHQVRFKCkgdG8gcmV0dXJuLCB3ZSBlZmZlY3RpdmVseSBpbnNlcnQgZXJy b3JfcHJvcGFnYXRlKCkKPj4gd2hlcmUgaXQgd2Fzbid0IGJlZm9yZS4gIERvZXMgbm90aGluZyB3 aGVuIHRoZSBsb2NhbCBlcnJvciBpcyBudWxsCj4+IHRoZXJlLiAgQnVnIGZpeCB3aGVuIGl0IGlz bid0OiBpdCdzIGF0IGxlYXN0IGEgbWVtb3J5IGxlYWssIGFuZCBxdWl0ZQo+PiBwb3NzaWJseSB3 b3JzZS4KPgo+IEhtbS4gSG93IGNhbiBpdCBiZSBtZW1vcnkgbGVhayBhZnRlciBhbnkgb2YgZXJy b3JfZnJlZSB2YXJpYW50cz8KCkNvbnNpZGVyIG5mc19vcHRpb25zX3FkaWN0X3RvX3FhcGkoKSBy aWdodCBiZWZvcmUgY29tbWl0IDU0YjdhZjQzNjlhCmZpeGVkIGl0OgoKICAgIHN0YXRpYyBCbG9j a2Rldk9wdGlvbnNOZnMgKm5mc19vcHRpb25zX3FkaWN0X3RvX3FhcGkoUURpY3QgKm9wdGlvbnMs CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IEVycm9yICoqZXJycCkKICAgIHsKICAgICAgICBCbG9ja2Rldk9wdGlvbnNOZnMgKm9wdHMgPSBO VUxMOwogICAgICAgIFFPYmplY3QgKmNydW1wbGVkID0gTlVMTDsKICAgICAgICBWaXNpdG9yICp2 OwogICAgICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwoKICAgICAgICBjcnVtcGxlZCA9IHFk aWN0X2NydW1wbGUob3B0aW9ucywgZXJycCk7CiAgICAgICAgaWYgKGNydW1wbGVkID09IE5VTEwp IHsKICAgICAgICAgICAgcmV0dXJuIE5VTEw7CiAgICAgICAgfQoKICAgICAgICB2ID0gcW9iamVj dF9pbnB1dF92aXNpdG9yX25ld19rZXl2YWwoY3J1bXBsZWQpOwogICAgICAgIHZpc2l0X3R5cGVf QmxvY2tkZXZPcHRpb25zTmZzKHYsIE5VTEwsICZvcHRzLCAmbG9jYWxfZXJyKTsKICAgICAgICB2 aXNpdF9mcmVlKHYpOwogICAgICAgIHFvYmplY3RfdW5yZWYoY3J1bXBsZWQpOwoKICAgICAgICBp ZiAobG9jYWxfZXJyKSB7CiAgICAgICAgICAgIHJldHVybiBOVUxMOwogICAgICAgIH0KCiAgICAg ICAgcmV0dXJuIG9wdHM7CiAgICB9CgpXaGVuIHZpc2l0X3R5cGVfQmxvY2tkZXZPcHRpb25zTmZz KCkgZmFpbHMsIHdlIHJldHVybiBudWxsIHdpdGhvdXQKc2V0dGluZyBhbiBlcnJvci4gIFdlIGFs c28gbGVhayB0aGUgZXJyb3Igd2UgZ290IGZyb20KdmlzaXRfdHlwZV9CbG9ja2Rldk9wdGlvbnNO ZnMoKS4KCkNvbW1pdCA1NGI3YWY0MzY5YSBmaXhlZCB0aGlzOgoKICAgIC0tLSBhL2Jsb2NrL25m cy5jCiAgICArKysgYi9ibG9jay9uZnMuYwogICAgQEAgLTU3MCw2ICs1NzAsNyBAQCBzdGF0aWMg QmxvY2tkZXZPcHRpb25zTmZzICpuZnNfb3B0aW9uc19xZGljdF90b19xYXBpKFFEaWN0ICoKICAg IG9wdGlvbnMsCiAgICAgICAgIHFvYmplY3RfdW5yZWYoY3J1bXBsZWQpOwoKICAgICAgICAgaWYg KGxvY2FsX2VycikgewogICAgKyAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vy cik7CiAgICAgICAgICAgICByZXR1cm4gTlVMTDsKICAgICAgICAgfQoKSWYgaXQgd2FzIHN0aWxs IGJyb2tlbiwgdGhlbiB5b3VyIHRyYW5zZm9ybWF0aW9uIHdvdWxkICphbHNvKiBmaXggaXQsCndv dWxkbid0IGl0PwoKTXkgcG9pbnQgaXM6IHlvdXIgdHJhbnNmb3JtYXRpb24gbWlnaHQgZml4IGFj dHVhbCBidWdzIQoKPj4gSWRlbnRpZnlpbmcgdGhlc2UgYnVnIGZpeGVzIHdvdWxkIGJlIG5pY2Us IGJ1dCBJIGRvbid0IGhhdmUgcHJhY3RpY2FsCj4+IGlkZWFzIG9uIGhvdyB0byBkbyB0aGF0Lgo+ Pgo+PiBDYW4gd2UgZXhwbGFpbiB0aGlzIGluIHRoZSBjb21taXQgbWVzc2FnZT8KPj4KPj4+ICsp Cj4+PiArICAgICAuLi4+Cj4+PiArIH0KPj4+ICsKPj4+ICtAQAo+Pj4gK2lkZW50aWZpZXIgcnVs ZTEuZm4sIHJ1bGUxLmxvY2FsX2VycjsKPj4+ICtAQAo+Pj4gKwo+Pj4gKyBmbiguLi4pCj4+PiAr IHsKPj4+ICsgICAgIDwuLi4KPj4+ICsoCj4+PiArLSAgICAmbG9jYWxfZXJyCj4+PiArKyAgICBl cnJwCj4+PiArfAo+Pj4gKy0gICAgbG9jYWxfZXJyCj4+PiArKyAgICAqZXJycAo+Pj4gKykKPj4+ ICsgICAgIC4uLj4KPj4+ICsgfQo+Pgo+PiBBbHNvIGluIHRhbmRlbSB3aXRoIHJ1bGUxLCBmaXhl cyB1cCB1c2VzIG9mIGxvY2FsX2Vyci4gIEdvb2QuCj4+Cj4+PiArCj4+PiArQEAKPj4+ICtpZGVu dGlmaWVyIHJ1bGUxLmZuOwo+Pj4gK0BACj4+PiArCj4+PiArIGZuKC4uLikKPj4+ICsgewo+Pj4g KyAgICAgPC4uLgo+Pj4gKy0gKmVycnAgIT0gTlVMTAo+Pj4gKysgKmVycnAKPj4+ICsgICAgIC4u Lj4KPj4+ICsgfQo+Pgo+PiBTdGlsbCBpbiB0YW5kZW0gd2l0aCBydWxlMSwgbm9ybWFsaXplcyBz dHlsZS4gIEdvb2QuCj4+CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJvamVj dC5vcmcKaHR0cHM6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hlbi1k ZXZlbA==