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=-10.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,NICE_REPLY_A, SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 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 9E10FC433B4 for ; Wed, 14 Apr 2021 07:23:15 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 6EA0C613A9 for ; Wed, 14 Apr 2021 07:23:15 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1349660AbhDNHXe (ORCPT ); Wed, 14 Apr 2021 03:23:34 -0400 Received: from ivanoab7.miniserver.com ([37.128.132.42]:34460 "EHLO www.kot-begemot.co.uk" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231231AbhDNHXb (ORCPT ); Wed, 14 Apr 2021 03:23:31 -0400 Received: from tun252.jain.kot-begemot.co.uk ([192.168.18.6] helo=jain.kot-begemot.co.uk) by www.kot-begemot.co.uk with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1lWZr5-0004AT-4T; Wed, 14 Apr 2021 07:22:35 +0000 Received: from madding.kot-begemot.co.uk ([192.168.3.98]) by jain.kot-begemot.co.uk with esmtps (TLS1.3:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.92) (envelope-from ) id 1lWZr2-0003Qz-Ki; Wed, 14 Apr 2021 08:22:30 +0100 Subject: Re: [PATCH 0/4 POC] Allow executing code and syscalls in another address space To: Andrei Vagin , linux-kernel@vger.kernel.org, linux-api@vger.kernel.org Cc: linux-um@lists.infradead.org, criu@openvz.org, avagin@google.com, Andrew Morton , Andy Lutomirski , Christian Brauner , Dmitry Safonov <0x7f454c46@gmail.com>, Ingo Molnar , Jeff Dike , Mike Rapoport , Michael Kerrisk , Oleg Nesterov , Peter Zijlstra , Richard Weinberger , Thomas Gleixner References: <20210414055217.543246-1-avagin@gmail.com> From: Anton Ivanov Organization: Cambridge Greys Message-ID: <78cdee11-1923-595f-90d2-e236efbafa6a@cambridgegreys.com> Date: Wed, 14 Apr 2021 08:22:28 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.9.0 MIME-Version: 1.0 In-Reply-To: <20210414055217.543246-1-avagin@gmail.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 8bit X-Clacks-Overhead: GNU Terry Pratchett Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 14/04/2021 06:52, Andrei Vagin wrote: > We already have process_vm_readv and process_vm_writev to read and write > to a process memory faster than we can do this with ptrace. And now it > is time for process_vm_exec that allows executing code in an address > space of another process. We can do this with ptrace but it is much > slower. > > = Use-cases = > > Here are two known use-cases. The first one is “application kernel” > sandboxes like User-mode Linux and gVisor. In this case, we have a > process that runs the sandbox kernel and a set of stub processes that > are used to manage guest address spaces. Guest code is executed in the > context of stub processes but all system calls are intercepted and > handled in the sandbox kernel. Right now, these sort of sandboxes use > PTRACE_SYSEMU to trap system calls, but the process_vm_exec can > significantly speed them up. Certainly interesting, but will require um to rework most of its memory management and we will most likely need extra mm support to make use of it in UML. We are not likely to get away just with one syscall there. > > Another use-case is CRIU (Checkpoint/Restore in User-space). Several > process properties can be received only from the process itself. Right > now, we use a parasite code that is injected into the process. We do > this with ptrace but it is slow, unsafe, and tricky. process_vm_exec can > simplify the process of injecting a parasite code and it will allow > pre-dump memory without stopping processes. The pre-dump here is when we > enable a memory tracker and dump the memory while a process is continue > running. On each interaction we dump memory that has been changed from > the previous iteration. In the final step, we will stop processes and > dump their full state. Right now the most effective way to dump process > memory is to create a set of pipes and splice memory into these pipes > from the parasite code. With process_vm_exec, we will be able to call > vmsplice directly. It means that we will not need to stop a process to > inject the parasite code. > > = How it works = > > process_vm_exec has two modes: > > * Execute code in an address space of a target process and stop on any > signal or system call. > > * Execute a system call in an address space of a target process. > > int process_vm_exec(pid_t pid, struct sigcontext uctx, > unsigned long flags, siginfo_t siginfo, > sigset_t *sigmask, size_t sizemask) > > PID - target process identification. We can consider to use pidfd > instead of PID here. > > sigcontext contains a process state with what the process will be > resumed after switching the address space and then when a process will > be stopped, its sate will be saved back to sigcontext. > > siginfo is information about a signal that has interrupted the process. > If a process is interrupted by a system call, signfo will contain a > synthetic siginfo of the SIGSYS signal. > > sigmask is a set of signals that process_vm_exec returns via signfo. > > # How fast is it > > In the fourth patch, you can find two benchmarks that execute a function > that calls system calls in a loop. ptrace_vm_exe uses ptrace to trap > system calls, proces_vm_exec uses the process_vm_exec syscall to do the > same thing. > > ptrace_vm_exec: 1446 ns/syscall > ptrocess_vm_exec: 289 ns/syscall > > PS: This version is just a prototype. Its goal is to collect the initial > feedback, to discuss the interfaces, and maybe to get some advice on > implementation.. > > Cc: Andrew Morton > Cc: Andy Lutomirski > Cc: Anton Ivanov > Cc: Christian Brauner > Cc: Dmitry Safonov <0x7f454c46@gmail.com> > Cc: Ingo Molnar > Cc: Jeff Dike > Cc: Mike Rapoport > Cc: Michael Kerrisk (man-pages) > Cc: Oleg Nesterov > Cc: Peter Zijlstra > Cc: Richard Weinberger > Cc: Thomas Gleixner > > Andrei Vagin (4): > signal: add a helper to restore a process state from sigcontex > arch/x86: implement the process_vm_exec syscall > arch/x86: allow to execute syscalls via process_vm_exec > selftests: add tests for process_vm_exec > > arch/Kconfig | 15 ++ > arch/x86/Kconfig | 1 + > arch/x86/entry/common.c | 19 +++ > arch/x86/entry/syscalls/syscall_64.tbl | 1 + > arch/x86/include/asm/sigcontext.h | 2 + > arch/x86/kernel/Makefile | 1 + > arch/x86/kernel/process_vm_exec.c | 160 ++++++++++++++++++ > arch/x86/kernel/signal.c | 125 ++++++++++---- > include/linux/entry-common.h | 2 + > include/linux/process_vm_exec.h | 17 ++ > include/linux/sched.h | 7 + > include/linux/syscalls.h | 6 + > include/uapi/asm-generic/unistd.h | 4 +- > include/uapi/linux/process_vm_exec.h | 8 + > kernel/entry/common.c | 2 +- > kernel/fork.c | 9 + > kernel/sys_ni.c | 2 + > .../selftests/process_vm_exec/Makefile | 7 + > tools/testing/selftests/process_vm_exec/log.h | 26 +++ > .../process_vm_exec/process_vm_exec.c | 105 ++++++++++++ > .../process_vm_exec/process_vm_exec_fault.c | 111 ++++++++++++ > .../process_vm_exec/process_vm_exec_syscall.c | 81 +++++++++ > .../process_vm_exec/ptrace_vm_exec.c | 111 ++++++++++++ > 23 files changed, 785 insertions(+), 37 deletions(-) > create mode 100644 arch/x86/kernel/process_vm_exec.c > create mode 100644 include/linux/process_vm_exec.h > create mode 100644 include/uapi/linux/process_vm_exec.h > create mode 100644 tools/testing/selftests/process_vm_exec/Makefile > create mode 100644 tools/testing/selftests/process_vm_exec/log.h > create mode 100644 tools/testing/selftests/process_vm_exec/process_vm_exec.c > create mode 100644 tools/testing/selftests/process_vm_exec/process_vm_exec_fault.c > create mode 100644 tools/testing/selftests/process_vm_exec/process_vm_exec_syscall.c > create mode 100644 tools/testing/selftests/process_vm_exec/ptrace_vm_exec.c > -- Anton R. Ivanov Cambridgegreys Limited. Registered in England. Company Number 10273661 https://www.cambridgegreys.com/ From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from ivanoab7.miniserver.com ([37.128.132.42] helo=www.kot-begemot.co.uk) by bombadil.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lWZrg-007ZHP-5I for linux-um@lists.infradead.org; Wed, 14 Apr 2021 07:23:09 +0000 Subject: Re: [PATCH 0/4 POC] Allow executing code and syscalls in another address space References: <20210414055217.543246-1-avagin@gmail.com> From: Anton Ivanov Message-ID: <78cdee11-1923-595f-90d2-e236efbafa6a@cambridgegreys.com> Date: Wed, 14 Apr 2021 08:22:28 +0100 MIME-Version: 1.0 In-Reply-To: <20210414055217.543246-1-avagin@gmail.com> Content-Language: en-US List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-um" Errors-To: linux-um-bounces+geert=linux-m68k.org@lists.infradead.org To: Andrei Vagin , linux-kernel@vger.kernel.org, linux-api@vger.kernel.org Cc: linux-um@lists.infradead.org, criu@openvz.org, avagin@google.com, Andrew Morton , Andy Lutomirski , Christian Brauner , Dmitry Safonov <0x7f454c46@gmail.com>, Ingo Molnar , Jeff Dike , Mike Rapoport , Michael Kerrisk , Oleg Nesterov , Peter Zijlstra , Richard Weinberger , Thomas Gleixner T24gMTQvMDQvMjAyMSAwNjo1MiwgQW5kcmVpIFZhZ2luIHdyb3RlOgo+IFdlIGFscmVhZHkgaGF2 ZSBwcm9jZXNzX3ZtX3JlYWR2IGFuZCBwcm9jZXNzX3ZtX3dyaXRldiB0byByZWFkIGFuZCB3cml0 ZQo+IHRvIGEgcHJvY2VzcyBtZW1vcnkgZmFzdGVyIHRoYW4gd2UgY2FuIGRvIHRoaXMgd2l0aCBw dHJhY2UuIEFuZCBub3cgaXQKPiBpcyB0aW1lIGZvciBwcm9jZXNzX3ZtX2V4ZWMgdGhhdCBhbGxv d3MgZXhlY3V0aW5nIGNvZGUgaW4gYW4gYWRkcmVzcwo+IHNwYWNlIG9mIGFub3RoZXIgcHJvY2Vz cy4gV2UgY2FuIGRvIHRoaXMgd2l0aCBwdHJhY2UgYnV0IGl0IGlzIG11Y2gKPiBzbG93ZXIuCj4g Cj4gPSBVc2UtY2FzZXMgPQo+IAo+IEhlcmUgYXJlIHR3byBrbm93biB1c2UtY2FzZXMuIFRoZSBm aXJzdCBvbmUgaXMg4oCcYXBwbGljYXRpb24ga2VybmVs4oCdCj4gc2FuZGJveGVzIGxpa2UgVXNl ci1tb2RlIExpbnV4IGFuZCBnVmlzb3IuIEluIHRoaXMgY2FzZSwgd2UgaGF2ZSBhCj4gcHJvY2Vz cyB0aGF0IHJ1bnMgdGhlIHNhbmRib3gga2VybmVsIGFuZCBhIHNldCBvZiBzdHViIHByb2Nlc3Nl cyB0aGF0Cj4gYXJlIHVzZWQgdG8gbWFuYWdlIGd1ZXN0IGFkZHJlc3Mgc3BhY2VzLiBHdWVzdCBj b2RlIGlzIGV4ZWN1dGVkIGluIHRoZQo+IGNvbnRleHQgb2Ygc3R1YiBwcm9jZXNzZXMgYnV0IGFs bCBzeXN0ZW0gY2FsbHMgYXJlIGludGVyY2VwdGVkIGFuZAo+IGhhbmRsZWQgaW4gdGhlIHNhbmRi b3gga2VybmVsLiBSaWdodCBub3csIHRoZXNlIHNvcnQgb2Ygc2FuZGJveGVzIHVzZQo+IFBUUkFD RV9TWVNFTVUgdG8gdHJhcCBzeXN0ZW0gY2FsbHMsIGJ1dCB0aGUgcHJvY2Vzc192bV9leGVjIGNh bgo+IHNpZ25pZmljYW50bHkgc3BlZWQgdGhlbSB1cC4KCkNlcnRhaW5seSBpbnRlcmVzdGluZywg YnV0IHdpbGwgcmVxdWlyZSB1bSB0byByZXdvcmsgbW9zdCBvZiBpdHMgbWVtb3J5IAptYW5hZ2Vt ZW50IGFuZCB3ZSB3aWxsIG1vc3QgbGlrZWx5IG5lZWQgZXh0cmEgbW0gc3VwcG9ydCB0byBtYWtl IHVzZSBvZiAKaXQgaW4gVU1MLiBXZSBhcmUgbm90IGxpa2VseSB0byBnZXQgYXdheSBqdXN0IHdp dGggb25lIHN5c2NhbGwgdGhlcmUuCgo+IAo+IEFub3RoZXIgdXNlLWNhc2UgaXMgQ1JJVSAoQ2hl Y2twb2ludC9SZXN0b3JlIGluIFVzZXItc3BhY2UpLiBTZXZlcmFsCj4gcHJvY2VzcyBwcm9wZXJ0 aWVzIGNhbiBiZSByZWNlaXZlZCBvbmx5IGZyb20gdGhlIHByb2Nlc3MgaXRzZWxmLiBSaWdodAo+ IG5vdywgd2UgdXNlIGEgcGFyYXNpdGUgY29kZSB0aGF0IGlzIGluamVjdGVkIGludG8gdGhlIHBy b2Nlc3MuIFdlIGRvCj4gdGhpcyB3aXRoIHB0cmFjZSBidXQgaXQgaXMgc2xvdywgdW5zYWZlLCBh bmQgdHJpY2t5LiBwcm9jZXNzX3ZtX2V4ZWMgY2FuCj4gc2ltcGxpZnkgdGhlIHByb2Nlc3Mgb2Yg aW5qZWN0aW5nIGEgcGFyYXNpdGUgY29kZSBhbmQgaXQgd2lsbCBhbGxvdwo+IHByZS1kdW1wIG1l bW9yeSB3aXRob3V0IHN0b3BwaW5nIHByb2Nlc3Nlcy4gVGhlIHByZS1kdW1wIGhlcmUgaXMgd2hl biB3ZQo+IGVuYWJsZSBhIG1lbW9yeSB0cmFja2VyIGFuZCBkdW1wIHRoZSBtZW1vcnkgd2hpbGUg YSBwcm9jZXNzIGlzIGNvbnRpbnVlCj4gcnVubmluZy4gT24gZWFjaCBpbnRlcmFjdGlvbiB3ZSBk dW1wIG1lbW9yeSB0aGF0IGhhcyBiZWVuIGNoYW5nZWQgZnJvbQo+IHRoZSBwcmV2aW91cyBpdGVy YXRpb24uIEluIHRoZSBmaW5hbCBzdGVwLCB3ZSB3aWxsIHN0b3AgcHJvY2Vzc2VzIGFuZAo+IGR1 bXAgdGhlaXIgZnVsbCBzdGF0ZS4gUmlnaHQgbm93IHRoZSBtb3N0IGVmZmVjdGl2ZSB3YXkgdG8g ZHVtcCBwcm9jZXNzCj4gbWVtb3J5IGlzIHRvIGNyZWF0ZSBhIHNldCBvZiBwaXBlcyBhbmQgc3Bs aWNlIG1lbW9yeSBpbnRvIHRoZXNlIHBpcGVzCj4gZnJvbSB0aGUgcGFyYXNpdGUgY29kZS4gV2l0 aCBwcm9jZXNzX3ZtX2V4ZWMsIHdlIHdpbGwgYmUgYWJsZSB0byBjYWxsCj4gdm1zcGxpY2UgZGly ZWN0bHkuIEl0IG1lYW5zIHRoYXQgd2Ugd2lsbCBub3QgbmVlZCB0byBzdG9wIGEgcHJvY2VzcyB0 bwo+IGluamVjdCB0aGUgcGFyYXNpdGUgY29kZS4KPiAKPiA9IEhvdyBpdCB3b3JrcyA9Cj4gCj4g cHJvY2Vzc192bV9leGVjIGhhcyB0d28gbW9kZXM6Cj4gCj4gKiBFeGVjdXRlIGNvZGUgaW4gYW4g YWRkcmVzcyBzcGFjZSBvZiBhIHRhcmdldCBwcm9jZXNzIGFuZCBzdG9wIG9uIGFueQo+ICAgIHNp Z25hbCBvciBzeXN0ZW0gY2FsbC4KPiAKPiAqIEV4ZWN1dGUgYSBzeXN0ZW0gY2FsbCBpbiBhbiBh ZGRyZXNzIHNwYWNlIG9mIGEgdGFyZ2V0IHByb2Nlc3MuCj4gCj4gaW50IHByb2Nlc3Nfdm1fZXhl YyhwaWRfdCBwaWQsIHN0cnVjdCBzaWdjb250ZXh0IHVjdHgsCj4gCQkgICAgdW5zaWduZWQgbG9u ZyBmbGFncywgc2lnaW5mb190IHNpZ2luZm8sCj4gCQkgICAgc2lnc2V0X3QgICpzaWdtYXNrLCBz aXplX3Qgc2l6ZW1hc2spCj4gCj4gUElEIC0gdGFyZ2V0IHByb2Nlc3MgaWRlbnRpZmljYXRpb24u IFdlIGNhbiBjb25zaWRlciB0byB1c2UgcGlkZmQKPiBpbnN0ZWFkIG9mIFBJRCBoZXJlLgo+IAo+ IHNpZ2NvbnRleHQgY29udGFpbnMgYSBwcm9jZXNzIHN0YXRlIHdpdGggd2hhdCB0aGUgcHJvY2Vz cyB3aWxsIGJlCj4gcmVzdW1lZCBhZnRlciBzd2l0Y2hpbmcgdGhlIGFkZHJlc3Mgc3BhY2UgYW5k IHRoZW4gd2hlbiBhIHByb2Nlc3Mgd2lsbAo+IGJlIHN0b3BwZWQsIGl0cyBzYXRlIHdpbGwgYmUg c2F2ZWQgYmFjayB0byBzaWdjb250ZXh0Lgo+IAo+IHNpZ2luZm8gaXMgaW5mb3JtYXRpb24gYWJv dXQgYSBzaWduYWwgdGhhdCBoYXMgaW50ZXJydXB0ZWQgdGhlIHByb2Nlc3MuCj4gSWYgYSBwcm9j ZXNzIGlzIGludGVycnVwdGVkIGJ5IGEgc3lzdGVtIGNhbGwsIHNpZ25mbyB3aWxsIGNvbnRhaW4g YQo+IHN5bnRoZXRpYyBzaWdpbmZvIG9mIHRoZSBTSUdTWVMgc2lnbmFsLgo+IAo+IHNpZ21hc2sg aXMgYSBzZXQgb2Ygc2lnbmFscyB0aGF0IHByb2Nlc3Nfdm1fZXhlYyByZXR1cm5zIHZpYSBzaWdu Zm8uCj4gCj4gIyBIb3cgZmFzdCBpcyBpdAo+IAo+IEluIHRoZSBmb3VydGggcGF0Y2gsIHlvdSBj YW4gZmluZCB0d28gYmVuY2htYXJrcyB0aGF0IGV4ZWN1dGUgYSBmdW5jdGlvbgo+IHRoYXQgY2Fs bHMgc3lzdGVtIGNhbGxzIGluIGEgbG9vcC4gcHRyYWNlX3ZtX2V4ZSB1c2VzIHB0cmFjZSB0byB0 cmFwCj4gc3lzdGVtIGNhbGxzLCBwcm9jZXNfdm1fZXhlYyB1c2VzIHRoZSBwcm9jZXNzX3ZtX2V4 ZWMgc3lzY2FsbCB0byBkbyB0aGUKPiBzYW1lIHRoaW5nLgo+IAo+IHB0cmFjZV92bV9leGVjOiAg IDE0NDYgbnMvc3lzY2FsbAo+IHB0cm9jZXNzX3ZtX2V4ZWM6ICAyODkgbnMvc3lzY2FsbAo+IAo+ IFBTOiBUaGlzIHZlcnNpb24gaXMganVzdCBhIHByb3RvdHlwZS4gSXRzIGdvYWwgaXMgdG8gY29s bGVjdCB0aGUgaW5pdGlhbAo+IGZlZWRiYWNrLCB0byBkaXNjdXNzIHRoZSBpbnRlcmZhY2VzLCBh bmQgbWF5YmUgdG8gZ2V0IHNvbWUgYWR2aWNlIG9uCj4gaW1wbGVtZW50YXRpb24uLgo+IAo+IENj OiBBbmRyZXcgTW9ydG9uIDxha3BtQGxpbnV4LWZvdW5kYXRpb24ub3JnPgo+IENjOiBBbmR5IEx1 dG9taXJza2kgPGx1dG9Aa2VybmVsLm9yZz4KPiBDYzogQW50b24gSXZhbm92IDxhbnRvbi5pdmFu b3ZAY2FtYnJpZGdlZ3JleXMuY29tPgo+IENjOiBDaHJpc3RpYW4gQnJhdW5lciA8Y2hyaXN0aWFu LmJyYXVuZXJAdWJ1bnR1LmNvbT4KPiBDYzogRG1pdHJ5IFNhZm9ub3YgPDB4N2Y0NTRjNDZAZ21h aWwuY29tPgo+IENjOiBJbmdvIE1vbG5hciA8bWluZ29AcmVkaGF0LmNvbT4KPiBDYzogSmVmZiBE aWtlIDxqZGlrZUBhZGR0b2l0LmNvbT4KPiBDYzogTWlrZSBSYXBvcG9ydCA8cnBwdEBsaW51eC5p Ym0uY29tPgo+IENjOiBNaWNoYWVsIEtlcnJpc2sgKG1hbi1wYWdlcykgPG10ay5tYW5wYWdlc0Bn bWFpbC5jb20+Cj4gQ2M6IE9sZWcgTmVzdGVyb3YgPG9sZWdAcmVkaGF0LmNvbT4KPiBDYzogUGV0 ZXIgWmlqbHN0cmEgPHBldGVyekBpbmZyYWRlYWQub3JnPgo+IENjOiBSaWNoYXJkIFdlaW5iZXJn ZXIgPHJpY2hhcmRAbm9kLmF0Pgo+IENjOiBUaG9tYXMgR2xlaXhuZXIgPHRnbHhAbGludXRyb25p eC5kZT4KPiAKPiBBbmRyZWkgVmFnaW4gKDQpOgo+ICAgIHNpZ25hbDogYWRkIGEgaGVscGVyIHRv IHJlc3RvcmUgYSBwcm9jZXNzIHN0YXRlIGZyb20gc2lnY29udGV4Cj4gICAgYXJjaC94ODY6IGlt cGxlbWVudCB0aGUgcHJvY2Vzc192bV9leGVjIHN5c2NhbGwKPiAgICBhcmNoL3g4NjogYWxsb3cg dG8gZXhlY3V0ZSBzeXNjYWxscyB2aWEgcHJvY2Vzc192bV9leGVjCj4gICAgc2VsZnRlc3RzOiBh ZGQgdGVzdHMgZm9yIHByb2Nlc3Nfdm1fZXhlYwo+IAo+ICAgYXJjaC9LY29uZmlnICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDE1ICsrCj4gICBhcmNoL3g4Ni9LY29uZmlnICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICAgYXJjaC94ODYvZW50cnkvY29t bW9uLmMgICAgICAgICAgICAgICAgICAgICAgIHwgIDE5ICsrKwo+ICAgYXJjaC94ODYvZW50cnkv c3lzY2FsbHMvc3lzY2FsbF82NC50YmwgICAgICAgIHwgICAxICsKPiAgIGFyY2gveDg2L2luY2x1 ZGUvYXNtL3NpZ2NvbnRleHQuaCAgICAgICAgICAgICB8ICAgMiArCj4gICBhcmNoL3g4Ni9rZXJu ZWwvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICAgYXJjaC94ODYva2Vy bmVsL3Byb2Nlc3Nfdm1fZXhlYy5jICAgICAgICAgICAgIHwgMTYwICsrKysrKysrKysrKysrKysr Kwo+ICAgYXJjaC94ODYva2VybmVsL3NpZ25hbC5jICAgICAgICAgICAgICAgICAgICAgIHwgMTI1 ICsrKysrKysrKystLS0tCj4gICBpbmNsdWRlL2xpbnV4L2VudHJ5LWNvbW1vbi5oICAgICAgICAg ICAgICAgICAgfCAgIDIgKwo+ICAgaW5jbHVkZS9saW51eC9wcm9jZXNzX3ZtX2V4ZWMuaCAgICAg ICAgICAgICAgIHwgIDE3ICsrCj4gICBpbmNsdWRlL2xpbnV4L3NjaGVkLmggICAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDcgKwo+ICAgaW5jbHVkZS9saW51eC9zeXNjYWxscy5oICAgICAgICAg ICAgICAgICAgICAgIHwgICA2ICsKPiAgIGluY2x1ZGUvdWFwaS9hc20tZ2VuZXJpYy91bmlzdGQu aCAgICAgICAgICAgICB8ICAgNCArLQo+ICAgaW5jbHVkZS91YXBpL2xpbnV4L3Byb2Nlc3Nfdm1f ZXhlYy5oICAgICAgICAgIHwgICA4ICsKPiAgIGtlcm5lbC9lbnRyeS9jb21tb24uYyAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgMiArLQo+ICAga2VybmVsL2ZvcmsuYyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICA5ICsKPiAgIGtlcm5lbC9zeXNfbmkuYyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgMiArCj4gICAuLi4vc2VsZnRlc3RzL3Byb2Nlc3Nfdm1f ZXhlYy9NYWtlZmlsZSAgICAgICAgfCAgIDcgKwo+ICAgdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMv cHJvY2Vzc192bV9leGVjL2xvZy5oIHwgIDI2ICsrKwo+ICAgLi4uL3Byb2Nlc3Nfdm1fZXhlYy9w cm9jZXNzX3ZtX2V4ZWMuYyAgICAgICAgIHwgMTA1ICsrKysrKysrKysrKwo+ICAgLi4uL3Byb2Nl c3Nfdm1fZXhlYy9wcm9jZXNzX3ZtX2V4ZWNfZmF1bHQuYyAgIHwgMTExICsrKysrKysrKysrKwo+ ICAgLi4uL3Byb2Nlc3Nfdm1fZXhlYy9wcm9jZXNzX3ZtX2V4ZWNfc3lzY2FsbC5jIHwgIDgxICsr KysrKysrKwo+ICAgLi4uL3Byb2Nlc3Nfdm1fZXhlYy9wdHJhY2Vfdm1fZXhlYy5jICAgICAgICAg IHwgMTExICsrKysrKysrKysrKwo+ICAgMjMgZmlsZXMgY2hhbmdlZCwgNzg1IGluc2VydGlvbnMo KyksIDM3IGRlbGV0aW9ucygtKQo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGFyY2gveDg2L2tlcm5l bC9wcm9jZXNzX3ZtX2V4ZWMuYwo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvbGludXgv cHJvY2Vzc192bV9leGVjLmgKPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL3VhcGkvbGlu dXgvcHJvY2Vzc192bV9leGVjLmgKPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCB0b29scy90ZXN0aW5n L3NlbGZ0ZXN0cy9wcm9jZXNzX3ZtX2V4ZWMvTWFrZWZpbGUKPiAgIGNyZWF0ZSBtb2RlIDEwMDY0 NCB0b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9wcm9jZXNzX3ZtX2V4ZWMvbG9nLmgKPiAgIGNyZWF0 ZSBtb2RlIDEwMDY0NCB0b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9wcm9jZXNzX3ZtX2V4ZWMvcHJv Y2Vzc192bV9leGVjLmMKPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCB0b29scy90ZXN0aW5nL3NlbGZ0 ZXN0cy9wcm9jZXNzX3ZtX2V4ZWMvcHJvY2Vzc192bV9leGVjX2ZhdWx0LmMKPiAgIGNyZWF0ZSBt b2RlIDEwMDY0NCB0b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9wcm9jZXNzX3ZtX2V4ZWMvcHJvY2Vz c192bV9leGVjX3N5c2NhbGwuYwo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IHRvb2xzL3Rlc3Rpbmcv c2VsZnRlc3RzL3Byb2Nlc3Nfdm1fZXhlYy9wdHJhY2Vfdm1fZXhlYy5jCj4gCgoKLS0gCkFudG9u IFIuIEl2YW5vdgpDYW1icmlkZ2VncmV5cyBMaW1pdGVkLiBSZWdpc3RlcmVkIGluIEVuZ2xhbmQu IENvbXBhbnkgTnVtYmVyIDEwMjczNjYxCmh0dHBzOi8vd3d3LmNhbWJyaWRnZWdyZXlzLmNvbS8K Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LXVt IG1haWxpbmcgbGlzdApsaW51eC11bUBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5p bmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtdW0K