From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id 0OgAGc+PCmhyvQMAWB0awg (envelope-from ) for ; Thu, 24 Apr 2025 15:23:59 -0400 Received: by simark.ca (Postfix, from userid 112) id 63AB91E0C3; Thu, 24 Apr 2025 15:23:59 -0400 (EDT) X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-25) on simark.ca X-Spam-Level: X-Spam-Status: No, score=-5.3 required=5.0 tests=ARC_SIGNED,ARC_VALID,BAYES_00, MAILING_LIST_MULTI,RCVD_IN_DNSWL_MED autolearn=ham autolearn_force=no version=4.0.1 Received: from server2.sourceware.org (server2.sourceware.org [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by simark.ca (Postfix) with ESMTPS id BE32D1E089 for ; Thu, 24 Apr 2025 15:23:57 -0400 (EDT) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 43D843858D26 for ; Thu, 24 Apr 2025 19:23:57 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 43D843858D26 Received: from mail-wr1-f42.google.com (mail-wr1-f42.google.com [209.85.221.42]) by sourceware.org (Postfix) with ESMTPS id 6D3723858D21 for ; Thu, 24 Apr 2025 19:23:13 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 6D3723858D21 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=palves.net Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 6D3723858D21 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=209.85.221.42 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1745522593; cv=none; b=jbHBzn1yN5t678+eD8nuWMCJMmXvBQaVLoUbhXfvNfB5/sApSrgxlr37oplmirb9NzsZCFr4Dps7zWXLdmvJUf/BhgpUSvtlRpvUtxuC/NqrYL94TbKrfKcyRqlG1mvXQ3BtG06CLP6jTxl2PRotEl2KuXWq4HIPCb5pv/qrIi4= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1745522593; c=relaxed/simple; bh=jz4VCz2EcqnGiTB3S1NOk1Yoa9HbmPEn1OGT5vRP14Q=; h=Message-ID:Date:MIME-Version:Subject:To:From; b=E5zbLgh5jGwqZO/sft1agRjfa9bbFr0NVmr+n1MEmF+u2t9InNQ5YxUoIT3U5ZhHNGJR1Btr/Zoc+D1AvfPWvOrxzqMRw64ugErnTxE01SlYFiZo9e+jt3jmGp2EBiESr6G6d3JdvQSC9uwN92alEK3eu5bVnsx6Pn1wy7MZjTU= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 6D3723858D21 Received: by mail-wr1-f42.google.com with SMTP id ffacd0b85a97d-3912fdddf8fso1787922f8f.1 for ; Thu, 24 Apr 2025 12:23:13 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1745522592; x=1746127392; h=in-reply-to:content-language:from:references:cc:to:subject :user-agent:mime-version:date:message-id:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=JlIwJwhjCc13kMRNik7Z5zNPyRz+6JH3I7CYkr8Rja8=; b=XZ2XWBpc/uB5fzmxgye5SAN6wCuCyXqbNBOQm5iili8knsxiJZBI4B4n/80puXflM2 6/WJH8WF/41IZjuKXgv7/bTlJ/WF77UZ2zIsV5U3naPjBQA3frHR9VFLqBNVSTF30lHm P6NCnaWyleTCRGEq2q8QAHKE4dVF126JJcUjd6+JT42zx1JGQkzBqOW74cnfhyumwONt YJJAulWGD6t+0IuRb/kb5vouolKa8yRyvq+3owAgvkTff1EqdeRDtQRUTmrzCY6Dbj7W kyxVrGbfePSHfCaq5A5i/YlSr57k4w95eIpjqvYZAH9QTvD8yql8nPC58fQA3XBKcLCZ 8CZg== X-Forwarded-Encrypted: i=1; AJvYcCXYvZUup3SYIVngEMDE7rrZUY+H+/ViwpFHn+ETu7eHdf/axwDLdlTEX5bXEzUMD+MCXOXwocRPZnqEMQ==@sourceware.org X-Gm-Message-State: AOJu0YyrA+zI2liLd8JN74j8gbH+R/dycVt4qbpcFVdv1F648yJtFuaQ U955Ige5lzEzloys2BhuhHb4rgpJX1j7inos+7+uHnTIVXGCrLhw X-Gm-Gg: ASbGncvXDZmvrTTcTdXBrTQsPEF5ni8U2CWnvkCzd95xygSRPwl6howKaFMTWFBmpo8 mG/CaYS0p0bNWhddvgo+VPMP+2i9uyT6vWwZrXF9k6dO2Ne4JoJciiWYU5hDjuH9vNzOx7tGg1h ZjxK3SfwsXoIGnmYrCVdXsP8nTnGgwHOAIAiMJfFvJobf1f2LsLzD+DMrm6urF1ktQbT3HDA+F1 XV4Bghiegg7tl1i8PcCYH3qev/Gwuxhrjt2Tl8HscC56+AfR97LvNmSBd0jW6exV6lWnRNQvw9z lZMQNAw/bA9rgaThW9q2TXX+RH1ld42G0JuQ28l1KTu9NEGnpVuZ7KT0JwNRbo7u2X0pkfMfi1C SuaLz7Uc2 X-Google-Smtp-Source: AGHT+IFR5jqYV6dxWIYnmggV/G9B5YNVhFaAy7yDM6tBI/ZIEUxj8HPg3l271102fh59+/eBuX1WBQ== X-Received: by 2002:a5d:5501:0:b0:39f:d13:32a with SMTP id ffacd0b85a97d-3a06d6c57c1mr2801291f8f.29.1745522591888; Thu, 24 Apr 2025 12:23:11 -0700 (PDT) Received: from ?IPV6:2001:8a0:4fcf:3e00:704c:2a3a:5212:7960? ([2001:8a0:4fcf:3e00:704c:2a3a:5212:7960]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3a073e5da0dsm116461f8f.88.2025.04.24.12.23.10 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Thu, 24 Apr 2025 12:23:11 -0700 (PDT) Content-Type: multipart/mixed; boundary="------------8QrVdy1bzaot0km0IDirig0C" Message-ID: <9f6d19b6-3d0a-4491-bfde-52daa45cefbe@palves.net> Date: Thu, 24 Apr 2025 20:23:06 +0100 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v3 2/2] gdb: add a '-stopped' option to "info threads" To: Tankut Baris Aktemur , gdb-patches@sourceware.org Cc: guinevere@redhat.com, eliz@gnu.org References: From: Pedro Alves Content-Language: en-US In-Reply-To: X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces~public-inbox=simark.ca@sourceware.org This is a multi-part message in MIME format. --------------8QrVdy1bzaot0km0IDirig0C Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit Hi! On 2025-04-04 14:36, Tankut Baris Aktemur wrote: > Add a '-stopped' option to the "info threads" command to print stopped > threads only and skip the running ones. This is a convenience flag to > filter out the running threads in programs that have many threads. > > Suppose we have an application with 5 threads, 2 of which have hit a > breakpoint. The "info threads" command in the non-stop mode gives: > > (gdb) info threads > Id Target Id Frame > * 1 Thread 0x7ffff7d99740 (running) > 2 Thread 0x7ffff7d98700 something () at file.c:30 > 3 Thread 0x7ffff7597700 (running) > 4 Thread 0x7ffff6d96700 something () at file.c:30 > 5 Thread 0x7ffff6595700 (running) > (gdb) > > Using the "-stopped" flag, we get > > (gdb) info threads -stopped > Id Target Id Frame > 2 Thread 0x7ffff7d98700 something () at file.c:30 > 4 Thread 0x7ffff6d96700 something () at file.c:30 > (gdb) > > When combined with a thread ID, the behavior is as follows: > > (gdb) info threads 3 > Id Target Id Frame > 3 Thread 0x7ffff7597700 (running) > (gdb) info threads -stopped 3 > No stopped threads match '3'. > (gdb) > > Regression-tested on X86_64 Linux. > > Reviewed-By: Eli Zaretskii > Reviewed-By: Guinevere Larsen > --- > gdb/NEWS | 5 + > gdb/doc/gdb.texinfo | 6 +- > gdb/testsuite/gdb.base/options.exp | 11 +- > .../gdb.threads/info-threads-stopped.c | 78 +++++++++++++ > .../gdb.threads/info-threads-stopped.exp | 107 ++++++++++++++++++ > gdb/thread.c | 17 ++- > 6 files changed, 220 insertions(+), 4 deletions(-) > create mode 100644 gdb/testsuite/gdb.threads/info-threads-stopped.c > create mode 100644 gdb/testsuite/gdb.threads/info-threads-stopped.exp > > diff --git a/gdb/NEWS b/gdb/NEWS > index 6a557bb4af9..d5c55c3c938 100644 > --- a/gdb/NEWS > +++ b/gdb/NEWS > @@ -56,6 +56,11 @@ info sharedlibrary > command are now for the full memory range allocated to the shared > library. > > +info threads [-gid] [-stopped] [ID]... > + This command now takes an optional flag, '-stopped', that causes only > + the stopped threads to be printed. The flag can be useful to get a > + reduced list when there is a large number of unstopped threads. Cool! (I would have added -running too while at it, and make "thread apply -stopped" work too. And then: "info threads -stopped -running" would print both stopped and running. Same logic as "info lanes -active -inactive" including both active and inactive in our offlist discussions.) > + > * Python API > > ** New class gdb.Color for dealing with colors. > diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo > index e034ac53295..3c03761dd00 100644 > --- a/gdb/doc/gdb.texinfo > +++ b/gdb/doc/gdb.texinfo > @@ -3807,7 +3807,7 @@ Thread 1 "main" received signal SIGINT, Interrupt. > @table @code > @anchor{info_threads} > @kindex info threads > -@item info threads @r{[}-gid@r{]} @r{[}@var{thread-id-list}@r{]} > +@item info threads @r{[}-gid@r{]} @r{[}-stopped@r{]} @r{[}@var{thread-id-list}@r{]} > > Display information about one or more threads. With no arguments > displays information about all threads. You can specify the list of > @@ -3857,6 +3857,10 @@ If you're debugging multiple inferiors, @value{GDBN} displays thread > IDs using the qualified @var{inferior-num}.@var{thread-num} format. > Otherwise, only @var{thread-num} is shown. > > +If you specify the @samp{-stopped} option, @value{GDBN} displays the > +stopped threads only. This can be helpful to reduce the output list > +if there is a large number of unstopped threads. > + > If you specify the @samp{-gid} option, @value{GDBN} displays a column > indicating each thread's global thread ID: > > diff --git a/gdb/testsuite/gdb.base/options.exp b/gdb/testsuite/gdb.base/options.exp > index 8760a918082..90902e94086 100644 > --- a/gdb/testsuite/gdb.base/options.exp > +++ b/gdb/testsuite/gdb.base/options.exp > @@ -509,12 +509,21 @@ proc_with_prefix test-thread-apply {} { > proc_with_prefix test-info-threads {} { > test_gdb_complete_multiple "info threads " "" "" { > "-gid" > + "-stopped" > "ID" > } > > + test_gdb_complete_multiple "info threads " "-" "" { > + "-gid" > + "-stopped" > + } > + > test_gdb_complete_unique \ > - "info threads -" \ > + "info threads -g" \ > "info threads -gid" > + test_gdb_complete_unique \ > + "info threads -s" \ > + "info threads -stopped" > > # "ID" isn't really something the user can type. > test_gdb_complete_none "info threads I" > diff --git a/gdb/testsuite/gdb.threads/info-threads-stopped.c b/gdb/testsuite/gdb.threads/info-threads-stopped.c > new file mode 100644 > index 00000000000..2c38ecca074 > --- /dev/null > +++ b/gdb/testsuite/gdb.threads/info-threads-stopped.c > @@ -0,0 +1,78 @@ > +/* This testcase is part of GDB, the GNU debugger. > + > + Copyright 2022-2025 Free Software Foundation, Inc. > + > + This program is free software; you can redistribute it and/or modify > + it under the terms of the GNU General Public License as published by > + the Free Software Foundation; either version 3 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 . */ > + > +#include > +#include > +#include > +#include > + > +#define NUM 4 > + > +volatile int should_spin = 1; > + > +static void > +something () > +{ > +} > + > +static void > +spin () > +{ > + while (should_spin) > + usleep (1); > +} > + > +static void * > +work (void *arg) > +{ > + int id = *((int *) arg); > + > + /* Sleep a bit to give the other threads a chance to run. */ > + usleep (1); This usleep isn't in a loop, so why is it needed? > + > + if (id % 2 == 0) > + something (); /* break-here */ > + else > + spin (); > + > + pthread_exit (NULL); > +} > + > +int > +main () > +{ > + /* Ensure we stop if GDB crashes and DejaGNU fails to kill us. */ > + alarm (10); This is 10 seconds ... > + > + pthread_t threads[NUM]; > + void *thread_result; > + int ids[NUM]; > + > + for (int i = 0; i < NUM; i++) > + { > + ids[i] = i + 2; > + pthread_create (&threads[i], NULL, work, &(ids[i])); > + } > + > + sleep (10); ... and this is 10 seconds too. Shouldn't the alarm clock be larger to give it a chance of clean exit? Actually better is to not have a timer at all. We can do that with a barrier that guarantees that we reach a breakpoint only after all threads have been seen. That fixes an issue which is that the test is expecting to hit two breakpoints, but it isn't waiting until the threads that are not supposed to hit a breakpoint actually start! Due to scheduling, you could end up doing "info threads" before all those threads are seen by GDB. Using a barrier fixes that. > + should_spin = 0; > + > + for (int i = 0; i < NUM; i++) > + pthread_join(threads[i], &thread_result); Space missing: "pthread_join (". You are not using thread_result for anything, so that could be: pthread_join (threads[i], NULL); But really, with a barrier and given the alarm, this is dead code, basically. Since we need a breakpoint after the barrier, might as well make the main thread hit the something() breakpoint too and be considered a stopped thread. (See attached patch.) > + > + return 0; > +} > diff --git a/gdb/testsuite/gdb.threads/info-threads-stopped.exp b/gdb/testsuite/gdb.threads/info-threads-stopped.exp > new file mode 100644 > index 00000000000..37d6622697c > --- /dev/null > +++ b/gdb/testsuite/gdb.threads/info-threads-stopped.exp > @@ -0,0 +1,107 @@ > +# Copyright (C) 2022-2025 Free Software Foundation, Inc. > + > +# This program is free software; you can redistribute it and/or modify > +# it under the terms of the GNU General Public License as published by > +# the Free Software Foundation; either version 3 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 . > + > +# Test for the '-stopped' flag of the "info threads" command. > + > +standard_testfile > + > +if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" \ > + executable debug] != "" } { > + return -1 > +} > + > +save_vars { GDBFLAGS } { > + append GDBFLAGS " -ex \"set non-stop on\"" > + clean_restart $binfile > +} > + > +gdb_breakpoint "something" > +gdb_run_cmd > + > +# Two threads hit the bp. > +set fill "\[^\r\n\]+" > +set num_hits 0 > +gdb_test_multiple "" "hit the breakpoint" -lbl { > + -re "\r\nThread ${fill} hit Breakpoint 1${fill}" { > + incr num_hits > + if {$num_hits < 2} { > + exp_continue > + } > + } > + -re "\r\n$gdb_prompt " { > + exp_continue > + } > +} It's better to write this in a way that explicitly always consumes the prompt. > +gdb_assert {$num_hits == 2} "two threads hit the bp" > + > +# We are in non-stop mode. > +# Send a simple command to resync the command prompt. > +gdb_test "p 42" " = 42" Then this shouldn't be needed. > + > +# Count the number of running/stopped threads reported > +# by the "info threads" command. We also capture thread ids > +# for additional tests. > +set running_tid "invalid" > +set stopped_tid "invalid" > + > +foreach flag {"" "-stopped"} { > + set num_running 0 > + set num_stopped 0 > + gdb_test_multiple "info threads $flag" "info threads $flag" { > + -re "Id${fill}Target Id${fill}Frame${fill}" { > + exp_continue > + } > + -re "^\r\n. (${decimal})${fill}Thread ${fill}.running." { > + incr num_running > + set running_tid $expect_out(1,string) > + exp_continue > + } > + -re "^\r\n. (${decimal})${fill}Thread ${fill}something ${fill}${srcfile}:${decimal}" { > + incr num_stopped > + set stopped_tid $expect_out(1,string) > + exp_continue > + } > + -re "^\r\n$gdb_prompt $" { > + gdb_assert {$num_stopped == 2} "$gdb_test_name: num stopped" > + if {$flag eq ""} { > + gdb_assert {$num_running == 3} "$gdb_test_name: num running" > + } else { > + gdb_assert {$num_running == 0} "$gdb_test_name: num running" It's better practice have the same number of PASSes and FAILs. They won't match if the prompt regexp doesn't match. > + } > + } > + } This needs some fixing around regexp matching. It is currently racy wrt to how much expect happens to manage to read into in the expect buffer at a time. If you run the test with "make check-read1" to force one byte at a time, it exposes the races reliably: $ make check-read1 TESTS="gdb.threads/info-threads-stopped.exp" ... FAIL: gdb.threads/info-threads-stopped.exp: info threads FAIL: gdb.threads/info-threads-stopped.exp: info threads -stopped === gdb Summary === # of expected passes 8 # of unexpected failures 2 I've attached a patch that fixes all the testcase issues that you can squash into yours. > +} > + > +gdb_assert {$running_tid != "invalid"} "found a running thread" > +gdb_assert {$stopped_tid != "invalid"} "found a stopped thread" > + > +# Test specifying thread ids. > +gdb_test "info threads -stopped $running_tid" \ > + "No stopped threads match '$running_tid'\." \ > + "info thread -stopped for a running thread" > + > +set fill "\[^\r\n\]+" > +set ws "\[ \t\]+" > +gdb_test "info threads -stopped $stopped_tid" \ > + [multi_line \ > + "${ws}Id${ws}Target Id${ws}Frame${ws}" \ > + "${ws}${stopped_tid}${ws}Thread ${fill} something ${fill}"] \ > + "info thread -stopped for a stopped thread" > + > +gdb_test "info threads -stopped $running_tid $stopped_tid" \ > + [multi_line \ > + "${ws}Id${ws}Target Id${ws}Frame${ws}" \ > + "${ws}${stopped_tid}${ws}Thread ${fill} something ${fill}"] \ > + "info thread -stopped for a running and a stopped thread" > diff --git a/gdb/thread.c b/gdb/thread.c > index 7dc8e7018c5..87ee9f66680 100644 > --- a/gdb/thread.c > +++ b/gdb/thread.c > @@ -1044,6 +1044,8 @@ struct info_threads_opts > { > /* For "-gid". */ > bool show_global_ids = false; > + /* For "-stopped". */ > + bool show_stopped_threads = false; > }; > > static const gdb::option::option_def info_threads_option_defs[] = { > @@ -1053,6 +1055,11 @@ static const gdb::option::option_def info_threads_option_defs[] = { > [] (info_threads_opts *opts) { return &opts->show_global_ids; }, > N_("Show global thread IDs."), > }, > + gdb::option::flag_option_def { > + "stopped", > + [] (info_threads_opts *opts) { return &opts->show_stopped_threads; }, > + N_("Show stopped threads only."), > + }, > > }; > > @@ -1095,6 +1102,11 @@ should_print_thread (const char *requested_threads, int default_inf_num, > if (thr->state == THREAD_EXITED) > return false; > > + /* Skip a running thread if the user wants stopped threads only. */ > + bool is_stopped = (thr->state == THREAD_STOPPED); > + if (opts.show_stopped_threads && !is_stopped) > + return false; > + > return true; > } > > @@ -1286,7 +1298,8 @@ print_thread_info_1 (struct ui_out *uiout, const char *requested_threads, > if (requested_threads == NULL || *requested_threads == '\0') > uiout->message (_("No threads.\n")); > else > - uiout->message (_("No threads match '%s'.\n"), > + uiout->message (_("No %sthreads match '%s'.\n"), > + (opts.show_stopped_threads ? "stopped " : ""), > requested_threads); I don't think we should do this. For one, it's not i18n friendly how that is written. Then, once we add a filter like "-running" too, then it'll get awkward with: (gdb) info threads -stopped -running *what would we say here?* I think the easiest is to just drop the %s part, and just say that no threads matched, like: if (!any_threads) uiout->message (_("No threads.\n")); else uiout->message (_("No threads matched.\n")); I've also attached a attached patch for this to make it easier to see what I mean. Note that "\." in your regexp does not match a period. It needs to be two back slashes "\\." as in my patch. Thanks, Pedro Alves --------------8QrVdy1bzaot0km0IDirig0C Content-Type: text/x-patch; charset=UTF-8; name="0001-Fix-test-races.patch" Content-Disposition: attachment; filename="0001-Fix-test-races.patch" Content-Transfer-Encoding: base64 RnJvbSBmODk1YzgyNDRmNjFhMjRkN2Q4NjYxYTAzMzMyNDcwNjk0MGJmZWY1IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBQZWRybyBBbHZlcyA8cGVkcm9AcGFsdmVzLm5ldD4K RGF0ZTogVGh1LCAyNCBBcHIgMjAyNSAyMDowOToxNiArMDEwMApTdWJqZWN0OiBbUEFUQ0gg MS8yXSBGaXggdGVzdCByYWNlcwoKQ2hhbmdlLUlkOiBJYTk4YTMxOTUyODJhODJmYzY4MTA0 ZjYxY2JhMTIxNmJmMGEyOTZhMAotLS0KIC4uLi9nZGIudGhyZWFkcy9pbmZvLXRocmVhZHMt c3RvcHBlZC5jICAgICAgICB8IDI3ICsrKysrLS0tLQogLi4uL2dkYi50aHJlYWRzL2luZm8t dGhyZWFkcy1zdG9wcGVkLmV4cCAgICAgIHwgNTYgKysrKysrKysrKy0tLS0tLS0tLQogMiBm aWxlcyBjaGFuZ2VkLCA0MiBpbnNlcnRpb25zKCspLCA0MSBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9nZGIvdGVzdHN1aXRlL2dkYi50aHJlYWRzL2luZm8tdGhyZWFkcy1zdG9wcGVk LmMgYi9nZGIvdGVzdHN1aXRlL2dkYi50aHJlYWRzL2luZm8tdGhyZWFkcy1zdG9wcGVkLmMK aW5kZXggMmMzOGVjY2EwNzQuLjJjNGNkODU0YmI3IDEwMDY0NAotLS0gYS9nZGIvdGVzdHN1 aXRlL2dkYi50aHJlYWRzL2luZm8tdGhyZWFkcy1zdG9wcGVkLmMKKysrIGIvZ2RiL3Rlc3Rz dWl0ZS9nZGIudGhyZWFkcy9pbmZvLXRocmVhZHMtc3RvcHBlZC5jCkBAIC0yMiwzMCArMjIs MjkgQEAKIAogI2RlZmluZSBOVU0gNAogCi12b2xhdGlsZSBpbnQgc2hvdWxkX3NwaW4gPSAx Oworc3RhdGljIHB0aHJlYWRfYmFycmllcl90IHRocmVhZHNfc3RhcnRlZF9iYXJyaWVyOwog CiBzdGF0aWMgdm9pZAotc29tZXRoaW5nICgpCitzdG9wX2hlcmUgKCkKIHsKIH0KIAogc3Rh dGljIHZvaWQKIHNwaW4gKCkKIHsKLSAgd2hpbGUgKHNob3VsZF9zcGluKQorICB3aGlsZSAo MSkKICAgICB1c2xlZXAgKDEpOwogfQogCiBzdGF0aWMgdm9pZCAqCiB3b3JrICh2b2lkICph cmcpCiB7Ci0gIGludCBpZCA9ICooKGludCAqKSBhcmcpOworICBpbnQgaWQgPSAqKGludCAq KSBhcmc7CiAKLSAgLyogU2xlZXAgYSBiaXQgdG8gZ2l2ZSB0aGUgb3RoZXIgdGhyZWFkcyBh IGNoYW5jZSB0byBydW4uICAqLwotICB1c2xlZXAgKDEpOworICBwdGhyZWFkX2JhcnJpZXJf d2FpdCAoJnRocmVhZHNfc3RhcnRlZF9iYXJyaWVyKTsKIAogICBpZiAoaWQgJSAyID09IDAp Ci0gICAgc29tZXRoaW5nICgpOyAvKiBicmVhay1oZXJlICovCisgICAgc3RvcF9oZXJlICgp OwogICBlbHNlCiAgICAgc3BpbiAoKTsKIApAQCAtNTksMjAgKzU4LDIwIEBAIG1haW4gKCkK ICAgYWxhcm0gKDEwKTsKIAogICBwdGhyZWFkX3QgdGhyZWFkc1tOVU1dOwotICB2b2lkICp0 aHJlYWRfcmVzdWx0OwogICBpbnQgaWRzW05VTV07CiAKKyAgcHRocmVhZF9iYXJyaWVyX2lu aXQgKCZ0aHJlYWRzX3N0YXJ0ZWRfYmFycmllciwgTlVMTCwgTlVNICsgMSk7CisKICAgZm9y IChpbnQgaSA9IDA7IGkgPCBOVU07IGkrKykKICAgICB7Ci0gICAgICBpZHNbaV0gPSBpICsg MjsKLSAgICAgIHB0aHJlYWRfY3JlYXRlICgmdGhyZWFkc1tpXSwgTlVMTCwgd29yaywgJihp ZHNbaV0pKTsKKyAgICAgIGlkc1tpXSA9IGk7CisgICAgICBwdGhyZWFkX2NyZWF0ZSAoJnRo cmVhZHNbaV0sIE5VTEwsIHdvcmssICZpZHNbaV0pOwogICAgIH0KIAotICBzbGVlcCAoMTAp OwotICBzaG91bGRfc3BpbiA9IDA7CisgIC8qIFdhaXQgdW50aWwgYWxsIHRocmVhZHMgYXJl IHNlZW4gcnVubmluZy4gICovCisgIHB0aHJlYWRfYmFycmllcl93YWl0ICgmdGhyZWFkc19z dGFydGVkX2JhcnJpZXIpOwogCi0gIGZvciAoaW50IGkgPSAwOyBpIDwgTlVNOyBpKyspCi0g ICAgcHRocmVhZF9qb2luKHRocmVhZHNbaV0sICZ0aHJlYWRfcmVzdWx0KTsKKyAgc3RvcF9o ZXJlICgpOwogCiAgIHJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZ2RiL3Rlc3RzdWl0ZS9n ZGIudGhyZWFkcy9pbmZvLXRocmVhZHMtc3RvcHBlZC5leHAgYi9nZGIvdGVzdHN1aXRlL2dk Yi50aHJlYWRzL2luZm8tdGhyZWFkcy1zdG9wcGVkLmV4cAppbmRleCAzN2Q2NjIyNjk3Yy4u ZDU1NGJkN2VmMmMgMTAwNjQ0Ci0tLSBhL2dkYi90ZXN0c3VpdGUvZ2RiLnRocmVhZHMvaW5m by10aHJlYWRzLXN0b3BwZWQuZXhwCisrKyBiL2dkYi90ZXN0c3VpdGUvZ2RiLnRocmVhZHMv aW5mby10aHJlYWRzLXN0b3BwZWQuZXhwCkBAIC0yNywyOCArMjcsMjkgQEAgc2F2ZV92YXJz IHsgR0RCRkxBR1MgfSB7CiAgICAgY2xlYW5fcmVzdGFydCAkYmluZmlsZQogfQogCi1nZGJf YnJlYWtwb2ludCAic29tZXRoaW5nIgotZ2RiX3J1bl9jbWQKK2lmICFbcnVudG9fbWFpbl0g eworICAgIHJldHVybiAtMQorfQorCitnZGJfYnJlYWtwb2ludCAic3RvcF9oZXJlIgorZ2Ri X3Rlc3RfbXVsdGlwbGUgImNvbnRpbnVlIC1hJiIgIiIgeworICAgIC1yZSAiQ29udGludWlu Zy5cclxuJGdkYl9wcm9tcHQgIiB7CisJcGFzcyAkZ2RiX3Rlc3RfbmFtZQorICAgIH0KK30K IAotIyBUd28gdGhyZWFkcyBoaXQgdGhlIGJwLgorc2V0IGV4cGVjdGVkX2hpdHMgMwogc2V0 IGZpbGwgIlxbXlxyXG5cXSsiCiBzZXQgbnVtX2hpdHMgMAogZ2RiX3Rlc3RfbXVsdGlwbGUg IiIgImhpdCB0aGUgYnJlYWtwb2ludCIgLWxibCB7Ci0gICAgLXJlICJcclxuVGhyZWFkICR7 ZmlsbH0gaGl0IEJyZWFrcG9pbnQgMSR7ZmlsbH0iIHsKKyAgICAtcmUgIlxyXG5UaHJlYWQg JHtmaWxsfSBoaXQgQnJlYWtwb2ludCAke2RlY2ltYWx9LCIgewogCWluY3IgbnVtX2hpdHMK LQlpZiB7JG51bV9oaXRzIDwgMn0geworCWlmIHskbnVtX2hpdHMgPCAkZXhwZWN0ZWRfaGl0 c30gewogCSAgICBleHBfY29udGludWUKIAl9CiAgICAgfQotICAgIC1yZSAiXHJcbiRnZGJf cHJvbXB0ICIgewotCWV4cF9jb250aW51ZQotICAgIH0KIH0KLWdkYl9hc3NlcnQgeyRudW1f aGl0cyA9PSAyfSAidHdvIHRocmVhZHMgaGl0IHRoZSBicCIKLQotIyBXZSBhcmUgaW4gbm9u LXN0b3AgbW9kZS4KLSMgU2VuZCBhIHNpbXBsZSBjb21tYW5kIHRvIHJlc3luYyB0aGUgY29t bWFuZCBwcm9tcHQuCi1nZGJfdGVzdCAicCA0MiIgIiA9IDQyIgorZ2RiX2Fzc2VydCB7JG51 bV9oaXRzID09ICRleHBlY3RlZF9oaXRzfSAiZXhwZWN0ZWQgdGhyZWFkcyBoaXQgdGhlIGJw IgogCiAjIENvdW50IHRoZSBudW1iZXIgb2YgcnVubmluZy9zdG9wcGVkIHRocmVhZHMgcmVw b3J0ZWQKICMgYnkgdGhlICJpbmZvIHRocmVhZHMiIGNvbW1hbmQuICBXZSBhbHNvIGNhcHR1 cmUgdGhyZWFkIGlkcwpAQCAtNTYsMzYgKzU3LDM3IEBAIGdkYl90ZXN0ICJwIDQyIiAiID0g NDIiCiBzZXQgcnVubmluZ190aWQgImludmFsaWQiCiBzZXQgc3RvcHBlZF90aWQgImludmFs aWQiCiAKK3NldCBlb2wgIig/PVxyXG4pIgorCiBmb3JlYWNoIGZsYWcgeyIiICItc3RvcHBl ZCJ9IHsKICAgICBzZXQgbnVtX3J1bm5pbmcgMAogICAgIHNldCBudW1fc3RvcHBlZCAwCi0g ICAgZ2RiX3Rlc3RfbXVsdGlwbGUgImluZm8gdGhyZWFkcyAkZmxhZyIgImluZm8gdGhyZWFk cyAkZmxhZyIgewotCS1yZSAiSWQke2ZpbGx9VGFyZ2V0IElkJHtmaWxsfUZyYW1lJHtmaWxs fSIgeworICAgIGdkYl90ZXN0X211bHRpcGxlICJpbmZvIHRocmVhZHMgJGZsYWciICJpbmZv IHRocmVhZHMgJGZsYWciIC1sYmwgeworCS1yZSAiSWQke2ZpbGx9VGFyZ2V0IElkJHtmaWxs fUZyYW1lJHtmaWxsfSR7ZW9sfSIgewogCSAgICBleHBfY29udGludWUKIAl9Ci0JLXJlICJe XHJcbi4gKCR7ZGVjaW1hbH0pJHtmaWxsfVRocmVhZCAke2ZpbGx9LnJ1bm5pbmcuIiB7CisJ LXJlICJeXHJcbi4gKCR7ZGVjaW1hbH0pJHtmaWxsfVRocmVhZCAke2ZpbGx9LnJ1bm5pbmcu JHtlb2x9IiB7CiAJICAgIGluY3IgbnVtX3J1bm5pbmcKIAkgICAgc2V0IHJ1bm5pbmdfdGlk ICRleHBlY3Rfb3V0KDEsc3RyaW5nKQogCSAgICBleHBfY29udGludWUKIAl9Ci0JLXJlICJe XHJcbi4gKCR7ZGVjaW1hbH0pJHtmaWxsfVRocmVhZCAke2ZpbGx9c29tZXRoaW5nICR7Zmls bH0ke3NyY2ZpbGV9OiR7ZGVjaW1hbH0iIHsKKwktcmUgIl5cclxuLiAoJHtkZWNpbWFsfSkk e2ZpbGx9VGhyZWFkICR7ZmlsbH1zdG9wX2hlcmUgJHtmaWxsfSR7c3JjZmlsZX06JHtkZWNp bWFsfSR7ZmlsbH0ke2VvbH0iIHsKIAkgICAgaW5jciBudW1fc3RvcHBlZAogCSAgICBzZXQg c3RvcHBlZF90aWQgJGV4cGVjdF9vdXQoMSxzdHJpbmcpCiAJICAgIGV4cF9jb250aW51ZQog CX0KIAktcmUgIl5cclxuJGdkYl9wcm9tcHQgJCIgewotCSAgICBnZGJfYXNzZXJ0IHskbnVt X3N0b3BwZWQgPT0gMn0gIiRnZGJfdGVzdF9uYW1lOiBudW0gc3RvcHBlZCIKLQkgICAgaWYg eyRmbGFnIGVxICIifSB7Ci0JCWdkYl9hc3NlcnQgeyRudW1fcnVubmluZyA9PSAzfSAiJGdk Yl90ZXN0X25hbWU6IG51bSBydW5uaW5nIgotCSAgICB9IGVsc2UgewotCQlnZGJfYXNzZXJ0 IHskbnVtX3J1bm5pbmcgPT0gMH0gIiRnZGJfdGVzdF9uYW1lOiBudW0gcnVubmluZyIKLQkg ICAgfQorCSAgICBwYXNzICRnZGJfdGVzdF9uYW1lCiAJfQogICAgIH0KIH0KIAotZ2RiX2Fz c2VydCB7JHJ1bm5pbmdfdGlkICE9ICJpbnZhbGlkIn0gImZvdW5kIGEgcnVubmluZyB0aHJl YWQiCi1nZGJfYXNzZXJ0IHskc3RvcHBlZF90aWQgIT0gImludmFsaWQifSAiZm91bmQgYSBz dG9wcGVkIHRocmVhZCIKK2dkYl9hc3NlcnQgeyRudW1fc3RvcHBlZCA9PSAzfSAibnVtIHN0 b3BwZWQiCitpZiB7JGZsYWcgZXEgIiJ9IHsKKyAgICBnZGJfYXNzZXJ0IHskbnVtX3J1bm5p bmcgPT0gMn0gIm51bSBydW5uaW5nIgorfSBlbHNlIHsKKyAgICBnZGJfYXNzZXJ0IHskbnVt X3J1bm5pbmcgPT0gMH0gIm51bSBydW5uaW5nIgorfQogCiAjIFRlc3Qgc3BlY2lmeWluZyB0 aHJlYWQgaWRzLgogZ2RiX3Rlc3QgImluZm8gdGhyZWFkcyAtc3RvcHBlZCAkcnVubmluZ190 aWQiIFwKQEAgLTk3LDExICs5OSwxMSBAQCBzZXQgd3MgIlxbIFx0XF0rIgogZ2RiX3Rlc3Qg ImluZm8gdGhyZWFkcyAtc3RvcHBlZCAkc3RvcHBlZF90aWQiIFwKICAgICBbbXVsdGlfbGlu ZSBcCiAJICIke3dzfUlkJHt3c31UYXJnZXQgSWQke3dzfUZyYW1lJHt3c30iIFwKLQkgIiR7 d3N9JHtzdG9wcGVkX3RpZH0ke3dzfVRocmVhZCAke2ZpbGx9IHNvbWV0aGluZyAke2ZpbGx9 Il0gXAorCSAiJHt3c30ke3N0b3BwZWRfdGlkfSR7d3N9VGhyZWFkICR7ZmlsbH0gc3RvcF9o ZXJlICR7ZmlsbH0iXSBcCiAgICAgImluZm8gdGhyZWFkIC1zdG9wcGVkIGZvciBhIHN0b3Bw ZWQgdGhyZWFkIgogCiBnZGJfdGVzdCAiaW5mbyB0aHJlYWRzIC1zdG9wcGVkICRydW5uaW5n X3RpZCAkc3RvcHBlZF90aWQiIFwKICAgICBbbXVsdGlfbGluZSBcCiAJICIke3dzfUlkJHt3 c31UYXJnZXQgSWQke3dzfUZyYW1lJHt3c30iIFwKLQkgIiR7d3N9JHtzdG9wcGVkX3RpZH0k e3dzfVRocmVhZCAke2ZpbGx9IHNvbWV0aGluZyAke2ZpbGx9Il0gXAorCSAiJHt3c30ke3N0 b3BwZWRfdGlkfSR7d3N9VGhyZWFkICR7ZmlsbH0gc3RvcF9oZXJlICR7ZmlsbH0iXSBcCiAg ICAgImluZm8gdGhyZWFkIC1zdG9wcGVkIGZvciBhIHJ1bm5pbmcgYW5kIGEgc3RvcHBlZCB0 aHJlYWQiCgpiYXNlLWNvbW1pdDogZTMyYjk3NmExNTI4OTRjMDBhMDFlNGUwYTQ4Y2QxZjFk ODJkMWQzOQpwcmVyZXF1aXNpdGUtcGF0Y2gtaWQ6IDM4Nzg2YWFkMTgxYTE3ODE2YTYzNzA4 ZGNhZTg4ZjhiZmZlZDU0NjkKcHJlcmVxdWlzaXRlLXBhdGNoLWlkOiBmNjQ0NzFkMGI0YmJi YjdjYjc4N2FlODI2ZTY1NGJhZjhjMWE1YmYzCi0tIAoyLjQ5LjAKCg== --------------8QrVdy1bzaot0km0IDirig0C Content-Type: text/x-patch; charset=UTF-8; name="0002-No-threads-matched.patch" Content-Disposition: attachment; filename="0002-No-threads-matched.patch" Content-Transfer-Encoding: base64 RnJvbSBhOGU0YmVjYTcyMWE5ZmIyNWZjMzA1MGJhYzJhNDQzNjBmODNmNzQzIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBQZWRybyBBbHZlcyA8cGVkcm9AcGFsdmVzLm5ldD4K RGF0ZTogVGh1LCAyNCBBcHIgMjAyNSAxOTozNjoxMiArMDEwMApTdWJqZWN0OiBbUEFUQ0gg Mi8yXSBObyB0aHJlYWRzIG1hdGNoZWQKCkNoYW5nZS1JZDogSTEyZWEzZDI4MzMxOWM4MjQ5 ODA3ZTcwZGU4OTBiNDBhZDNhMDBmN2QKLS0tCiAuLi4vZ2RiLnRocmVhZHMvaW5mby10aHJl YWRzLXN0b3BwZWQuZXhwICAgICAgIHwgIDIgKy0KIGdkYi90aHJlYWQuYyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgfCAxOCArKysrKysrKy0tLS0tLS0tLS0KIDIgZmls ZXMgY2hhbmdlZCwgOSBpbnNlcnRpb25zKCspLCAxMSBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9nZGIvdGVzdHN1aXRlL2dkYi50aHJlYWRzL2luZm8tdGhyZWFkcy1zdG9wcGVkLmV4 cCBiL2dkYi90ZXN0c3VpdGUvZ2RiLnRocmVhZHMvaW5mby10aHJlYWRzLXN0b3BwZWQuZXhw CmluZGV4IGQ1NTRiZDdlZjJjLi42NjBlZDRhYTE5NyAxMDA2NDQKLS0tIGEvZ2RiL3Rlc3Rz dWl0ZS9nZGIudGhyZWFkcy9pbmZvLXRocmVhZHMtc3RvcHBlZC5leHAKKysrIGIvZ2RiL3Rl c3RzdWl0ZS9nZGIudGhyZWFkcy9pbmZvLXRocmVhZHMtc3RvcHBlZC5leHAKQEAgLTkxLDcg KzkxLDcgQEAgaWYgeyRmbGFnIGVxICIifSB7CiAKICMgVGVzdCBzcGVjaWZ5aW5nIHRocmVh ZCBpZHMuCiBnZGJfdGVzdCAiaW5mbyB0aHJlYWRzIC1zdG9wcGVkICRydW5uaW5nX3RpZCIg XAotICAgICJObyBzdG9wcGVkIHRocmVhZHMgbWF0Y2ggJyRydW5uaW5nX3RpZCdcLiIgXAor ICAgICJObyB0aHJlYWRzIG1hdGNoZWRcXC4iIFwKICAgICAiaW5mbyB0aHJlYWQgLXN0b3Bw ZWQgZm9yIGEgcnVubmluZyB0aHJlYWQiCiAKIHNldCBmaWxsICJcW15cclxuXF0rIgpkaWZm IC0tZ2l0IGEvZ2RiL3RocmVhZC5jIGIvZ2RiL3RocmVhZC5jCmluZGV4IDcwNTdmYTFkNjQx Li43NDg1ZGNjZThkNiAxMDA2NDQKLS0tIGEvZ2RiL3RocmVhZC5jCisrKyBiL2dkYi90aHJl YWQuYwpAQCAtMTI2NywxMyArMTI2NywxNSBAQCBwcmludF90aHJlYWRfaW5mb18xIChzdHJ1 Y3QgdWlfb3V0ICp1aW91dCwgY29uc3QgY2hhciAqcmVxdWVzdGVkX3RocmVhZHMsCiAgICAg ICBsaXN0X2VtaXR0ZXIuZW1wbGFjZSAodWlvdXQsICJ0aHJlYWRzIik7CiAgICAgZWxzZQog ICAgICAgewotCWludCBuX3RocmVhZHMgPSAwOworCWludCBuX21hdGNoaW5nX3RocmVhZHMg PSAwOwogCS8qIFRoZSB3aWR0aCBvZiB0aGUgIlRhcmdldCBJZCIgY29sdW1uLiAgR3Jvd24g YmVsb3cgdG8KIAkgICBhY2NvbW1vZGF0ZSB0aGUgbGFyZ2VzdCBlbnRyeS4gICovCiAJc2l6 ZV90IHRhcmdldF9pZF9jb2xfd2lkdGggPSAxNzsKIAogCWZvciAodGhyZWFkX2luZm8gKnRw IDogYWxsX3RocmVhZHMgKCkpCiAJICB7CisJICAgIGFueV90aHJlYWQgPSB0cnVlOworCiAJ ICAgIC8qIEluIGNhc2UgUkVRVUVTVEVEX1RIUkVBRFMgY29udGFpbnMgJF90aHJlYWQuICAq LwogCSAgICBpZiAoY3VycmVudF90aHJlYWQgIT0gbnVsbHB0cikKIAkgICAgICBzd2l0Y2hf dG9fdGhyZWFkIChjdXJyZW50X3RocmVhZCk7CkBAIC0xMjkwLDIyICsxMjkyLDIwIEBAIHBy aW50X3RocmVhZF9pbmZvXzEgKHN0cnVjdCB1aV9vdXQgKnVpb3V0LCBjb25zdCBjaGFyICpy ZXF1ZXN0ZWRfdGhyZWFkcywKIAkgICAgICA9IHN0ZDo6bWF4ICh0YXJnZXRfaWRfY29sX3dp ZHRoLAogCQkJICB0aHJlYWRfdGFyZ2V0X2lkX3N0ciAodHApLnNpemUgKCkpOwogCi0JICAg ICsrbl90aHJlYWRzOworCSAgICArK25fbWF0Y2hpbmdfdGhyZWFkczsKIAkgIH0KIAotCWlm IChuX3RocmVhZHMgPT0gMCkKKwlpZiAobl9tYXRjaGluZ190aHJlYWRzID09IDApCiAJICB7 Ci0JICAgIGlmIChyZXF1ZXN0ZWRfdGhyZWFkcyA9PSBOVUxMIHx8ICpyZXF1ZXN0ZWRfdGhy ZWFkcyA9PSAnXDAnKQorCSAgICBpZiAoIWFueV90aHJlYWQpCiAJICAgICAgdWlvdXQtPm1l c3NhZ2UgKF8oIk5vIHRocmVhZHMuXG4iKSk7CiAJICAgIGVsc2UKLQkgICAgICB1aW91dC0+ bWVzc2FnZSAoXygiTm8gJXN0aHJlYWRzIG1hdGNoICclcycuXG4iKSwKLQkJCSAgICAgIChv cHRzLnNob3dfc3RvcHBlZF90aHJlYWRzID8gInN0b3BwZWQgIiA6ICIiKSwKLQkJCSAgICAg IHJlcXVlc3RlZF90aHJlYWRzKTsKKwkgICAgICB1aW91dC0+bWVzc2FnZSAoXygiTm8gdGhy ZWFkcyBtYXRjaGVkLlxuIikpOwogCSAgICByZXR1cm47CiAJICB9CiAKIAl0YWJsZV9lbWl0 dGVyLmVtcGxhY2UgKHVpb3V0LCBvcHRzLnNob3dfZ2xvYmFsX2lkcyA/IDUgOiA0LAotCQkJ ICAgICAgIG5fdGhyZWFkcywgInRocmVhZHMiKTsKKwkJCSAgICAgICBuX21hdGNoaW5nX3Ro cmVhZHMsICJ0aHJlYWRzIik7CiAKIAl1aW91dC0+dGFibGVfaGVhZGVyICgxLCB1aV9sZWZ0 LCAiY3VycmVudCIsICIiKTsKIAl1aW91dC0+dGFibGVfaGVhZGVyICg0LCB1aV9sZWZ0LCAi aWQtaW4tdGciLCAiSWQiKTsKQEAgLTEzMjAsOCArMTMyMCw2IEBAIHByaW50X3RocmVhZF9p bmZvXzEgKHN0cnVjdCB1aV9vdXQgKnVpb3V0LCBjb25zdCBjaGFyICpyZXF1ZXN0ZWRfdGhy ZWFkcywKICAgICBmb3IgKGluZmVyaW9yICppbmYgOiBhbGxfaW5mZXJpb3JzICgpKQogICAg ICAgZm9yICh0aHJlYWRfaW5mbyAqdHAgOiBpbmYtPnRocmVhZHMgKCkpCiAJewotCSAgYW55 X3RocmVhZCA9IHRydWU7Ci0KIAkgIGlmICh0cCA9PSBjdXJyZW50X3RocmVhZCAmJiB0cC0+ c3RhdGUgPT0gVEhSRUFEX0VYSVRFRCkKIAkgICAgY3VycmVudF9leGl0ZWQgPSB0cnVlOwog Ci0tIAoyLjQ5LjAKCg== --------------8QrVdy1bzaot0km0IDirig0C--