From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-oi1-x22a.google.com (mail-oi1-x22a.google.com [IPv6:2607:f8b0:4864:20::22a]) by sourceware.org (Postfix) with ESMTPS id 00C83396E871 for ; Tue, 13 Jul 2021 19:49:52 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 00C83396E871 Received: by mail-oi1-x22a.google.com with SMTP id t25so11143343oiw.13 for ; Tue, 13 Jul 2021 12:49:52 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=b9LK5EFJ2vyhc847LQ1tiV42bODEYLfTXAGF2LXAqRI=; b=BIsqAXdc+TGglRkmzti5dcF3eN2w6Op7cd0azC339+A302+lOjRFPSj/cL4dzAOfpQ PmoNzwInmUGZNIVw8Ny7RHWN99SoVVWNl1MhPGmxiGK6Vlgpfdgd2fCbE6004jwTJhAK Wj4JIvq3jPX7tYi87ercl35zGFdaYiht6TCPEgbct0z8TiwEuq+KQKkWQYKJrxnMREah NFx0DOK0bb2iCPRHENoPVws/IIhGPOaLUb5Nj2tN9SFGEkMMSUXTT2CoaNyl5Z2MCpRk stbJJgpZGtNi+OSq+cTVR+C9OokvUxu42OIp5gzxDm2SZZ2uXU28gmKqTNPZFht0uLna 72Yg== X-Gm-Message-State: AOAM5328d4oWIPkVC0FqLIwyKXJvNJ3CjPpeN0ovskVBkvRmmV8jly4n zDIEWl6SWkZA0ltIp9O0z9lUJTKT1cF60MQyaFk= X-Google-Smtp-Source: ABdhPJynF3LVCQTkEnycmMr2PyBVK313449DexGqC9BApx7VAQbaLauz9BwI2VX3ClcrR87ypkuiFsS01TEtyKVlNrM= X-Received: by 2002:a05:6808:1388:: with SMTP id c8mr810173oiw.17.1626205792355; Tue, 13 Jul 2021 12:49:52 -0700 (PDT) MIME-Version: 1.0 References: <20210601145516.3553627-1-hjl.tools@gmail.com> <20210601145516.3553627-2-hjl.tools@gmail.com> <19675287-dc96-6aed-392d-b9aab1504c49@linaro.org> In-Reply-To: <19675287-dc96-6aed-392d-b9aab1504c49@linaro.org> From: "H.J. Lu" Date: Tue, 13 Jul 2021 12:49:16 -0700 Message-ID: Subject: [PATCH v9] Add an internal wrapper for clone, clone2 and clone3 To: Adhemerval Zanella Cc: GNU C Library , Florian Weimer , Noah Goldstein Content-Type: multipart/mixed; boundary="00000000000095e83105c7068abc" X-Spam-Status: No, score=-3031.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, KAM_LOTSOFHASH, KAM_NUMSUBJECT, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 13 Jul 2021 19:49:57 -0000 --00000000000095e83105c7068abc Content-Type: text/plain; charset="UTF-8" On Tue, Jul 13, 2021 at 11:54 AM Adhemerval Zanella wrote: > > > > On 01/06/2021 11:55, H.J. Lu wrote: > > The clone3 system call provides a superset of the functionality of clone > > and clone2. It also provides a number of API improvements, including > > the ability to specify the size of the child's stack area which can be > > used by kernel to compute the shadow stack size when allocating the > > shadow stack. Add: > > > > extern int __clone_internal (struct clone_args *__cl_args, > > int (*__func) (void *__arg), void *__arg); > > > > to provide an abstract interface for clone, clone2 and clone3. > > > > 1. Simplify stack management for thread creation by passing both stack > > base and size to create_thread. > > 2. Consolidate clone vs clone2 differences into a single file. > > 3. Call __clone3 if HAVE_CLONE3_WAPPER is defined. If __clone3 returns > > -1 with ENOSYS, fall back to clone or clone2. > > 4. Use only __clone_internal to clone a thread. Since the stack size > > argument for create_thread is now unconditional, always pass stack size > > to create_thread. > > 5. Enable the public clone3 wrapper in the future after it has been > > added to all targets. > > > > NB: Sandbox should return ENOSYS on clone3 if it is rejected: > > > > https://bugs.chromium.org/p/chromium/issues/detail?id=1213452#c5 > > LGTM with just an suggestion below. Also chromium also has fixed it, > so although it wouldn't be able to fully handled clone3, at least > it won't brick a 2.34 glibc. > > Reviewed-by: Adhemerval Zanella > > > --- > > include/clone_internal.h | 16 +++++ > > nptl/allocatestack.c | 59 ++------------- > > nptl/pthread_create.c | 38 +++++----- > > sysdeps/unix/sysv/linux/Makefile | 2 +- > > sysdeps/unix/sysv/linux/clone-internal.c | 91 ++++++++++++++++++++++++ > > sysdeps/unix/sysv/linux/clone3.c | 1 + > > sysdeps/unix/sysv/linux/clone3.h | 60 ++++++++++++++++ > > sysdeps/unix/sysv/linux/spawni.c | 26 +++---- > > 8 files changed, 205 insertions(+), 88 deletions(-) > > create mode 100644 include/clone_internal.h > > create mode 100644 sysdeps/unix/sysv/linux/clone-internal.c > > create mode 100644 sysdeps/unix/sysv/linux/clone3.c > > create mode 100644 sysdeps/unix/sysv/linux/clone3.h > > > > diff --git a/include/clone_internal.h b/include/clone_internal.h > > new file mode 100644 > > index 0000000000..4b23ef33ce > > --- /dev/null > > +++ b/include/clone_internal.h > > @@ -0,0 +1,16 @@ > > +#ifndef _CLONE3_H > > +#include_next > > + > > +extern __typeof (clone3) __clone3; > > + > > +/* The internal wrapper of clone/clone2 and clone3. If __clone3 returns > > + -1 with ENOSYS, fall back to clone or clone2. */ > > +extern int __clone_internal (struct clone_args *__cl_args, > > + int (*__func) (void *__arg), void *__arg); > > + > > +#ifndef _ISOMAC > > +libc_hidden_proto (__clone3) > > +libc_hidden_proto (__clone_internal) > > +#endif > > + > > +#endif > > Ok. > > > diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c > > index dc81a2ca73..eebf9c2c3c 100644 > > --- a/nptl/allocatestack.c > > +++ b/nptl/allocatestack.c > > @@ -33,47 +33,6 @@ > > #include > > #include > > > > -#ifndef NEED_SEPARATE_REGISTER_STACK > > - > > -/* Most architectures have exactly one stack pointer. Some have more. */ > > -# define STACK_VARIABLES void *stackaddr = NULL > > - > > -/* How to pass the values to the 'create_thread' function. */ > > -# define STACK_VARIABLES_ARGS stackaddr > > - > > -/* How to declare function which gets there parameters. */ > > -# define STACK_VARIABLES_PARMS void *stackaddr > > - > > -/* How to declare allocate_stack. */ > > -# define ALLOCATE_STACK_PARMS void **stack > > - > > -/* This is how the function is called. We do it this way to allow > > - other variants of the function to have more parameters. */ > > -# define ALLOCATE_STACK(attr, pd) allocate_stack (attr, pd, &stackaddr) > > - > > -#else > > - > > -/* We need two stacks. The kernel will place them but we have to tell > > - the kernel about the size of the reserved address space. */ > > -# define STACK_VARIABLES void *stackaddr = NULL; size_t stacksize = 0 > > - > > -/* How to pass the values to the 'create_thread' function. */ > > -# define STACK_VARIABLES_ARGS stackaddr, stacksize > > - > > -/* How to declare function which gets there parameters. */ > > -# define STACK_VARIABLES_PARMS void *stackaddr, size_t stacksize > > - > > -/* How to declare allocate_stack. */ > > -# define ALLOCATE_STACK_PARMS void **stack, size_t *stacksize > > - > > -/* This is how the function is called. We do it this way to allow > > - other variants of the function to have more parameters. */ > > -# define ALLOCATE_STACK(attr, pd) \ > > - allocate_stack (attr, pd, &stackaddr, &stacksize) > > - > > -#endif > > - > > - > > /* Default alignment of stack. */ > > #ifndef STACK_ALIGN > > # define STACK_ALIGN __alignof__ (long double) > > Ok. > > > @@ -249,7 +208,7 @@ advise_stack_range (void *mem, size_t size, uintptr_t pd, size_t guardsize) > > PDP must be non-NULL. */ > > static int > > allocate_stack (const struct pthread_attr *attr, struct pthread **pdp, > > - ALLOCATE_STACK_PARMS) > > + void **stack, size_t *stacksize) > > { > > struct pthread *pd; > > size_t size; > > @@ -600,25 +559,17 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp, > > /* We place the thread descriptor at the end of the stack. */ > > *pdp = pd; > > > > -#if _STACK_GROWS_DOWN > > void *stacktop; > > > > -# if TLS_TCB_AT_TP > > +#if TLS_TCB_AT_TP > > /* The stack begins before the TCB and the static TLS block. */ > > stacktop = ((char *) (pd + 1) - tls_static_size_for_stack); > > -# elif TLS_DTV_AT_TP > > +#elif TLS_DTV_AT_TP > > stacktop = (char *) (pd - 1); > > -# endif > > +#endif > > > > -# ifdef NEED_SEPARATE_REGISTER_STACK > > + *stacksize = stacktop - pd->stackblock; > > *stack = pd->stackblock; > > - *stacksize = stacktop - *stack; > > -# else > > - *stack = stacktop; > > -# endif > > -#else > > - *stack = pd->stackblock; > > -#endif > > > > return 0; > > } > > Ok. > > > diff --git a/nptl/pthread_create.c b/nptl/pthread_create.c > > index 2d2535b07d..9e3b8f325c 100644 > > --- a/nptl/pthread_create.c > > +++ b/nptl/pthread_create.c > > @@ -37,6 +37,7 @@ > > #include "libioP.h" > > #include > > #include > > +#include > > > > #include > > > > @@ -246,8 +247,8 @@ late_init (void) > > static int _Noreturn start_thread (void *arg); > > > > static int create_thread (struct pthread *pd, const struct pthread_attr *attr, > > - bool *stopped_start, STACK_VARIABLES_PARMS, > > - bool *thread_ran) > > + bool *stopped_start, void *stackaddr, > > + size_t stacksize, bool *thread_ran) > > { > > /* Determine whether the newly created threads has to be started > > stopped since we have to set the scheduling parameters or set the > > @@ -299,14 +300,18 @@ static int create_thread (struct pthread *pd, const struct pthread_attr *attr, > > > > TLS_DEFINE_INIT_TP (tp, pd); > > > > -#ifdef __NR_clone2 > > -# define ARCH_CLONE __clone2 > > -#else > > -# define ARCH_CLONE __clone > > -#endif > > - if (__glibc_unlikely (ARCH_CLONE (&start_thread, STACK_VARIABLES_ARGS, > > - clone_flags, pd, &pd->tid, tp, &pd->tid) > > - == -1)) > > + struct clone_args args = > > + { > > + .flags = clone_flags, > > + .pidfd = (uintptr_t) &pd->tid, > > + .parent_tid = (uintptr_t) &pd->tid, > > + .child_tid = (uintptr_t) &pd->tid, > > + .stack = (uintptr_t) stackaddr, > > + .stack_size = stacksize, > > + .tls = (uintptr_t) tp, > > + }; > > + int ret = __clone_internal (&args, &start_thread, pd); > > + if (__glibc_unlikely (ret == -1)) > > return errno; > > > > /* It's started now, so if we fail below, we'll have to cancel it > > Ok. > > > @@ -603,7 +608,8 @@ int > > __pthread_create_2_1 (pthread_t *newthread, const pthread_attr_t *attr, > > void *(*start_routine) (void *), void *arg) > > { > > - STACK_VARIABLES; > > + void *stackaddr = NULL; > > + size_t stacksize = 0; > > > > /* Avoid a data race in the multi-threaded case, and call the > > deferred initialization only once. */ > > @@ -627,7 +633,7 @@ __pthread_create_2_1 (pthread_t *newthread, const pthread_attr_t *attr, > > } > > > > struct pthread *pd = NULL; > > - int err = ALLOCATE_STACK (iattr, &pd); > > + int err = allocate_stack (iattr, &pd, &stackaddr, &stacksize); > > int retval = 0; > > > > if (__glibc_unlikely (err != 0)) > > @@ -772,8 +778,8 @@ __pthread_create_2_1 (pthread_t *newthread, const pthread_attr_t *attr, > > > > /* We always create the thread stopped at startup so we can > > notify the debugger. */ > > - retval = create_thread (pd, iattr, &stopped_start, > > - STACK_VARIABLES_ARGS, &thread_ran); > > + retval = create_thread (pd, iattr, &stopped_start, stackaddr, > > + stacksize, &thread_ran); > > if (retval == 0) > > { > > /* We retain ownership of PD until (a) (see CONCURRENCY NOTES > > @@ -804,8 +810,8 @@ __pthread_create_2_1 (pthread_t *newthread, const pthread_attr_t *attr, > > } > > } > > else > > - retval = create_thread (pd, iattr, &stopped_start, > > - STACK_VARIABLES_ARGS, &thread_ran); > > + retval = create_thread (pd, iattr, &stopped_start, stackaddr, > > + stacksize, &thread_ran); > > > > /* Return to the previous signal mask, after creating the new > > thread. */ > > Ok. > > > diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile > > index bc14f20274..9469868bce 100644 > > --- a/sysdeps/unix/sysv/linux/Makefile > > +++ b/sysdeps/unix/sysv/linux/Makefile > > @@ -64,7 +64,7 @@ sysdep_routines += adjtimex clone umount umount2 readahead sysctl \ > > time64-support pselect32 \ > > xstat fxstat lxstat xstat64 fxstat64 lxstat64 \ > > fxstatat fxstatat64 \ > > - xmknod xmknodat > > + xmknod xmknodat clone3 clone-internal > > > > CFLAGS-gethostid.c = -fexceptions > > CFLAGS-tee.c = -fexceptions -fasynchronous-unwind-tables > > Ok. > > > diff --git a/sysdeps/unix/sysv/linux/clone-internal.c b/sysdeps/unix/sysv/linux/clone-internal.c > > new file mode 100644 > > index 0000000000..1e7a8f6b35 > > --- /dev/null > > +++ b/sysdeps/unix/sysv/linux/clone-internal.c > > @@ -0,0 +1,91 @@ > > +/* The internal wrapper of clone and clone3. > > + Copyright (C) 2021 Free Software Foundation, Inc. > > + This file is part of the GNU C Library. > > + > > + The GNU C Library is free software; you can redistribute it and/or > > + modify it under the terms of the GNU Lesser General Public > > + License as published by the Free Software Foundation; either > > + version 2.1 of the License, or (at your option) any later version. > > + > > + The GNU C Library 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 > > + Lesser General Public License for more details. > > + > > + You should have received a copy of the GNU Lesser General Public > > + License along with the GNU C Library. If not, see > > + . */ > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include /* For cast_to_pointer. */ > > +#include /* For _STACK_GROWS_{UP,DOWN}. */ > > + > > +#define CLONE_ARGS_SIZE_VER0 64 /* sizeof first published struct */ > > +#define CLONE_ARGS_SIZE_VER1 80 /* sizeof second published struct */ > > +#define CLONE_ARGS_SIZE_VER2 88 /* sizeof third published struct */ > > + > > +#define sizeof_field(TYPE, MEMBER) sizeof ((((TYPE *)0)->MEMBER)) > > +#define offsetofend(TYPE, MEMBER) \ > > + (offsetof (TYPE, MEMBER) + sizeof_field (TYPE, MEMBER)) > > + > > +_Static_assert (__alignof (struct clone_args) == 8, > > + "__alignof (struct clone_args) != 8"); > > +_Static_assert (offsetofend (struct clone_args, tls) == CLONE_ARGS_SIZE_VER0, > > + "offsetofend (struct clone_args, tls) != CLONE_ARGS_SIZE_VER0"); > > +_Static_assert (offsetofend (struct clone_args, set_tid_size) == CLONE_ARGS_SIZE_VER1, > > + "offsetofend (struct clone_args, set_tid_size) != CLONE_ARGS_SIZE_VER1"); > > +_Static_assert (offsetofend (struct clone_args, cgroup) == CLONE_ARGS_SIZE_VER2, > > + "offsetofend (struct clone_args, cgroup) != CLONE_ARGS_SIZE_VER2"); > > +_Static_assert (sizeof (struct clone_args) == CLONE_ARGS_SIZE_VER2, > > + "sizeof (struct clone_args) != CLONE_ARGS_SIZE_VER2"); > > + > > +int > > +__clone_internal (struct clone_args *cl_args, > > + int (*func) (void *arg), void *arg) > > +{ > > + int ret; > > +#ifdef HAVE_CLONE3_WAPPER > > + /* Try clone3 first. */ > > + int saved_errno = errno; > > + ret = __clone3 (cl_args, sizeof (*cl_args), func, arg); > > + if (ret != -1 || errno != ENOSYS) > > + return ret; > > + > > + /* NB: Restore errno since errno may be checked against non-zero > > + return value. */ > > + __set_errno (saved_errno); > > +#endif > > + > > + /* Map clone3 arguments to clone arguments. NB: No need to check > > + invalid clone3 specific bits in flags nor exit_signal since this > > + is an internal function. */ > > + int flags = cl_args->flags | cl_args->exit_signal; > > + void *stack = cast_to_pointer (cl_args->stack); > > + > > +#ifdef __ia64__ > > + ret = __clone2 (func, stack, cl_args->stack_size, > > + flags, arg, > > + cast_to_pointer (cl_args->parent_tid), > > + cast_to_pointer (cl_args->tls), > > + cast_to_pointer (cl_args->child_tid)); > > +#else > > +# if !_STACK_GROWS_DOWN && !_STACK_GROWS_UP > > +# error "Define either _STACK_GROWS_DOWN or _STACK_GROWS_UP" > > +# endif > > + > > +# if _STACK_GROWS_DOWN > > + stack += cl_args->stack_size; > > +# endif > > + ret = __clone (func, stack, flags, arg, > > + cast_to_pointer (cl_args->parent_tid), > > + cast_to_pointer (cl_args->tls), > > + cast_to_pointer (cl_args->child_tid)); > > +#endif > > + return ret; > > +} > > + > > +libc_hidden_def (__clone_internal) > > Ok. > > > diff --git a/sysdeps/unix/sysv/linux/clone3.c b/sysdeps/unix/sysv/linux/clone3.c > > new file mode 100644 > > index 0000000000..de963ef89d > > --- /dev/null > > +++ b/sysdeps/unix/sysv/linux/clone3.c > > @@ -0,0 +1 @@ > > +/* An empty placeholder. */ > > Ok. > > > diff --git a/sysdeps/unix/sysv/linux/clone3.h b/sysdeps/unix/sysv/linux/clone3.h > > new file mode 100644 > > index 0000000000..0488884d59 > > --- /dev/null > > +++ b/sysdeps/unix/sysv/linux/clone3.h > > @@ -0,0 +1,60 @@ > > +/* The wrapper of clone3. > > + Copyright (C) 2021 Free Software Foundation, Inc. > > + This file is part of the GNU C Library. > > + > > + The GNU C Library is free software; you can redistribute it and/or > > + modify it under the terms of the GNU Lesser General Public > > + License as published by the Free Software Foundation; either > > + version 2.1 of the License, or (at your option) any later version. > > + > > + The GNU C Library 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 > > + Lesser General Public License for more details. > > + > > + You should have received a copy of the GNU Lesser General Public > > + License along with the GNU C Library. If not, see > > + . */ > > + > > +#ifndef _CLONE3_H > > +#define _CLONE3_H 1 > > + > > +#include > > +#include > > +#include > > + > > +__BEGIN_DECLS > > + > > +/* This struct should only be used in an argument to the clone3 system > > + call (along with its size argument). It may be extended with new > > + fields in the future. */ > > + > > +struct clone_args > > +{ > > + uint64_t flags; /* Flags bit mask. */ > > + uint64_t pidfd; /* Where to store PID file descriptor > > + (pid_t *). */ > > + uint64_t child_tid; /* Where to store child TID, in child's memory > > + (pid_t *). */ > > + uint64_t parent_tid; /* Where to store child TID, in parent's memory > > + (int *). */ > > + uint64_t exit_signal; /* Signal to deliver to parent on child > > + termination */ > > + uint64_t stack; /* The lowest address of stack. */ > > + uint64_t stack_size; /* Size of stack. */ > > + uint64_t tls; /* Location of new TLS. */ > > + uint64_t set_tid; /* Pointer to a pid_t array > > + (since Linux 5.5). */ > > + uint64_t set_tid_size; /* Number of elements in set_tid > > + (since Linux 5.5). */ > > + uint64_t cgroup; /* File descriptor for target cgroup > > + of child (since Linux 5.7). */ > > +} __attribute__ ((aligned (8))); > > + > > The kernel defined the alignment for each member (__aligned_u64) instead > of aligning the struct itself. It should ok as lon all member are the > same type, but I am not sure if kernel decide to extend using different > internal types. Maybe we should mimic kernel in this regard. I added __aligned_uint64_t to sysdeps/unix/sysv/linux/clone3.h. We can improve it if it becomes an installed header file. > > +/* The wrapper of clone3. */ > > +extern int clone3 (struct clone_args *__cl_args, size_t __size, > > + int (*__func) (void *__arg), void *__arg); > > + > > +__END_DECLS > > + > > +#endif /* clone3.h */ > > Ok. > > > diff --git a/sysdeps/unix/sysv/linux/spawni.c b/sysdeps/unix/sysv/linux/spawni.c > > index 501f8fbccd..fd29858cf5 100644 > > --- a/sysdeps/unix/sysv/linux/spawni.c > > +++ b/sysdeps/unix/sysv/linux/spawni.c > > @@ -31,6 +31,7 @@ > > #include > > #include > > #include > > +#include > > #include "spawn_int.h" > > > > /* The Linux implementation of posix_spawn{p} uses the clone syscall directly > > @@ -59,21 +60,6 @@ > > normal program exit with the exit code 127. */ > > #define SPAWN_ERROR 127 > > > > -#ifdef __ia64__ > > -# define CLONE(__fn, __stackbase, __stacksize, __flags, __args) \ > > - __clone2 (__fn, __stackbase, __stacksize, __flags, __args, 0, 0, 0) > > -#else > > -# define CLONE(__fn, __stack, __stacksize, __flags, __args) \ > > - __clone (__fn, __stack, __flags, __args) > > -#endif > > - > > -/* Since ia64 wants the stackbase w/clone2, re-use the grows-up macro. */ > > -#if _STACK_GROWS_UP || defined (__ia64__) > > -# define STACK(__stack, __stack_size) (__stack) > > -#elif _STACK_GROWS_DOWN > > -# define STACK(__stack, __stack_size) (__stack + __stack_size) > > -#endif > > - > > > > Ok. > > > struct posix_spawn_args > > { > > @@ -378,8 +364,14 @@ __spawnix (pid_t * pid, const char *file, > > need for CLONE_SETTLS. Although parent and child share the same TLS > > namespace, there will be no concurrent access for TLS variables (errno > > for instance). */ > > - new_pid = CLONE (__spawni_child, STACK (stack, stack_size), stack_size, > > - CLONE_VM | CLONE_VFORK | SIGCHLD, &args); > > + struct clone_args clone_args = > > + { > > + .flags = CLONE_VM | CLONE_VFORK, > > + .exit_signal = SIGCHLD, > > + .stack = (uintptr_t) stack, > > + .stack_size = stack_size, > > + }; > > + new_pid = __clone_internal (&clone_args, __spawni_child, &args); > > > > /* It needs to collect the case where the auxiliary process was created > > but failed to execute the file (due either any preparation step or > > > > Ok. Here is the v9 patch. Thanks. -- H.J. --00000000000095e83105c7068abc Content-Type: text/x-patch; charset="US-ASCII"; name="v9-0001-Add-an-internal-wrapper-for-clone-clone2-and-clon.patch" Content-Disposition: attachment; filename="v9-0001-Add-an-internal-wrapper-for-clone-clone2-and-clon.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_kr2gwoyt0 RnJvbSBlYWQzMWJkZjgzYjBhNzMyNzMzOTliMTc4ODVmM2M4MWM1YWQzYjgzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiAiSC5KLiBMdSIgPGhqbC50b29sc0BnbWFpbC5jb20+CkRhdGU6 IFNhdCwgMTMgRmViIDIwMjEgMTE6NDc6NDYgLTA4MDAKU3ViamVjdDogW1BBVENIIHY5XSBBZGQg YW4gaW50ZXJuYWwgd3JhcHBlciBmb3IgY2xvbmUsIGNsb25lMiBhbmQgY2xvbmUzCgpUaGUgY2xv bmUzIHN5c3RlbSBjYWxsIChzaW5jZSBMaW51eCA1LjMpIHByb3ZpZGVzIGEgc3VwZXJzZXQgb2Yg dGhlCmZ1bmN0aW9uYWxpdHkgb2YgY2xvbmUgYW5kIGNsb25lMi4gIEl0IGFsc28gcHJvdmlkZXMg YSBudW1iZXIgb2YgQVBJCmltcHJvdmVtZW50cywgaW5jbHVkaW5nIHRoZSBhYmlsaXR5IHRvIHNw ZWNpZnkgdGhlIHNpemUgb2YgdGhlIGNoaWxkJ3MKc3RhY2sgYXJlYSB3aGljaCBjYW4gYmUgdXNl ZCBieSBrZXJuZWwgdG8gY29tcHV0ZSB0aGUgc2hhZG93IHN0YWNrIHNpemUKd2hlbiBhbGxvY2F0 aW5nIHRoZSBzaGFkb3cgc3RhY2suICBBZGQ6CgpleHRlcm4gaW50IF9fY2xvbmVfaW50ZXJuYWwg KHN0cnVjdCBjbG9uZV9hcmdzICpfX2NsX2FyZ3MsCgkJCSAgICAgaW50ICgqX19mdW5jKSAodm9p ZCAqX19hcmcpLCB2b2lkICpfX2FyZyk7Cgp0byBwcm92aWRlIGFuIGFic3RyYWN0IGludGVyZmFj ZSBmb3IgY2xvbmUsIGNsb25lMiBhbmQgY2xvbmUzLgoKMS4gU2ltcGxpZnkgc3RhY2sgbWFuYWdl bWVudCBmb3IgdGhyZWFkIGNyZWF0aW9uIGJ5IHBhc3NpbmcgYm90aCBzdGFjawpiYXNlIGFuZCBz aXplIHRvIGNyZWF0ZV90aHJlYWQuCjIuIENvbnNvbGlkYXRlIGNsb25lIHZzIGNsb25lMiBkaWZm ZXJlbmNlcyBpbnRvIGEgc2luZ2xlIGZpbGUuCjMuIENhbGwgX19jbG9uZTMgaWYgSEFWRV9DTE9O RTNfV0FQUEVSIGlzIGRlZmluZWQuICBJZiBfX2Nsb25lMyByZXR1cm5zCi0xIHdpdGggRU5PU1lT LCBmYWxsIGJhY2sgdG8gY2xvbmUgb3IgY2xvbmUyLgo0LiBVc2Ugb25seSBfX2Nsb25lX2ludGVy bmFsIHRvIGNsb25lIGEgdGhyZWFkLiAgU2luY2UgdGhlIHN0YWNrIHNpemUKYXJndW1lbnQgZm9y IGNyZWF0ZV90aHJlYWQgaXMgbm93IHVuY29uZGl0aW9uYWwsIGFsd2F5cyBwYXNzIHN0YWNrIHNp emUKdG8gY3JlYXRlX3RocmVhZC4KNS4gRW5hYmxlIHRoZSBwdWJsaWMgY2xvbmUzIHdyYXBwZXIg aW4gdGhlIGZ1dHVyZSBhZnRlciBpdCBoYXMgYmVlbgphZGRlZCB0byBhbGwgdGFyZ2V0cy4KCk5C OiBTYW5kYm94IHdpbGwgcmV0dXJuIEVOT1NZUyBvbiBjbG9uZTMgaW4gYm90aCBDaHJvbWl1bToK ClRoZSBmb2xsb3dpbmcgcmV2aXNpb24gcmVmZXJzIHRvIHRoaXMgYnVnOgogIGh0dHBzOi8vY2hy b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMvKy8yMTg0MzgyNTlkZDc5NTQ1NmYw YTQ4ZjY3Y2JlNWI0ZTUyMGRiODhiCgpjb21taXQgMjE4NDM4MjU5ZGQ3OTU0NTZmMGE0OGY2N2Ni ZTViNGU1MjBkYjg4YgpBdXRob3I6IE1hdHRoZXcgRGVudG9uIDxtcGRlbnRvbkBjaHJvbWl1bS5v cmc+CkRhdGU6IFRodSBKdW4gMDMgMjA6MDY6MTMgMjAyMQoKTGludXggc2FuZGJveDogcmV0dXJu IEVOT1NZUyBmb3IgY2xvbmUzCgpCZWNhdXNlIGNsb25lMyB1c2VzIGEgcG9pbnRlciBhcmd1bWVu dCByYXRoZXIgdGhhbiBhIGZsYWdzIGFyZ3VtZW50LCB3ZQpjYW5ub3QgZXhhbWluZSB0aGUgY29u dGVudHMgd2l0aCBzZWNjb21wLCB3aGljaCBpcyBlc3NlbnRpYWwgdG8KcHJldmVudGluZyBzYW5k Ym94ZWQgcHJvY2Vzc2VzIGZyb20gc3RhcnRpbmcgb3RoZXIgcHJvY2Vzc2VzLiBTbywgd2UKd29u J3QgYmUgYWJsZSB0byBzdXBwb3J0IGNsb25lMyBpbiBDaHJvbWl1bS4gVGhpcyBDTCBtb2RpZmll cyB0aGUKQlBGIHBvbGljeSB0byByZXR1cm4gRU5PU1lTIGZvciBjbG9uZTMgc28gZ2xpYmMgYWx3 YXlzIHVzZXMgdGhlIGZhbGxiYWNrCnRvIGNsb25lLgoKQnVnOiAxMjEzNDUyCkNoYW5nZS1JZDog STdjN2M1ODVhMzE5ZTAyNjRlYWM1YjFlYmVlMWE0NWJlMmQ3ODIzMDMKUmV2aWV3ZWQtb246IGh0 dHBzOi8vY2hyb21pdW0tcmV2aWV3Lmdvb2dsZXNvdXJjZS5jb20vYy9jaHJvbWl1bS9zcmMvKy8y OTM2MTg0ClJldmlld2VkLWJ5OiBSb2JlcnQgU2VzZWsgPHJzZXNla0BjaHJvbWl1bS5vcmc+CkNv bW1pdC1RdWV1ZTogTWF0dGhldyBEZW50b24gPG1wZGVudG9uQGNocm9taXVtLm9yZz4KQ3ItQ29t bWl0LVBvc2l0aW9uOiByZWZzL2hlYWRzL21hc3RlckB7Izg4ODk4MH0KClttb2RpZnldIGh0dHBz Oi8vY3JyZXYuY29tLzIxODQzODI1OWRkNzk1NDU2ZjBhNDhmNjdjYmU1YjRlNTIwZGI4OGIvc2Fu ZGJveC9saW51eC9zZWNjb21wLWJwZi1oZWxwZXJzL2Jhc2VsaW5lX3BvbGljeS5jYwoKYW5kIEZp cmVmb3g6CgpodHRwczovL2hnLm1vemlsbGEub3JnL2ludGVncmF0aW9uL2F1dG9sYW5kL3Jldi9l Y2I0MDExYTBjNzYKLS0tCiBpbmNsdWRlL2Nsb25lX2ludGVybmFsLmggICAgICAgICAgICAgICAg IHwgMTYgKysrKysKIG5wdGwvYWxsb2NhdGVzdGFjay5jICAgICAgICAgICAgICAgICAgICAgfCA1 OSArKy0tLS0tLS0tLS0tLS0KIG5wdGwvcHRocmVhZF9jcmVhdGUuYyAgICAgICAgICAgICAgICAg ICAgfCAzOCArKysrKy0tLS0tCiBzeXNkZXBzL3VuaXgvc3lzdi9saW51eC9NYWtlZmlsZSAgICAg ICAgIHwgIDMgKy0KIHN5c2RlcHMvdW5peC9zeXN2L2xpbnV4L2Nsb25lLWludGVybmFsLmMgfCA5 MSArKysrKysrKysrKysrKysrKysrKysrKysKIHN5c2RlcHMvdW5peC9zeXN2L2xpbnV4L2Nsb25l My5jICAgICAgICAgfCAgMSArCiBzeXNkZXBzL3VuaXgvc3lzdi9saW51eC9jbG9uZTMuaCAgICAg ICAgIHwgNjcgKysrKysrKysrKysrKysrKysKIHN5c2RlcHMvdW5peC9zeXN2L2xpbnV4L3NwYXdu aS5jICAgICAgICAgfCAyNiArKystLS0tCiA4IGZpbGVzIGNoYW5nZWQsIDIxMyBpbnNlcnRpb25z KCspLCA4OCBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2Nsb25lX2lu dGVybmFsLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzeXNkZXBzL3VuaXgvc3lzdi9saW51eC9jbG9u ZS1pbnRlcm5hbC5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3lzZGVwcy91bml4L3N5c3YvbGludXgv Y2xvbmUzLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzeXNkZXBzL3VuaXgvc3lzdi9saW51eC9jbG9u ZTMuaAoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvY2xvbmVfaW50ZXJuYWwuaCBiL2luY2x1ZGUvY2xv bmVfaW50ZXJuYWwuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwLi40YjIz ZWYzM2NlCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS9jbG9uZV9pbnRlcm5hbC5oCkBAIC0w LDAgKzEsMTYgQEAKKyNpZm5kZWYgX0NMT05FM19ICisjaW5jbHVkZV9uZXh0IDxjbG9uZTMuaD4K KworZXh0ZXJuIF9fdHlwZW9mIChjbG9uZTMpIF9fY2xvbmUzOworCisvKiBUaGUgaW50ZXJuYWwg d3JhcHBlciBvZiBjbG9uZS9jbG9uZTIgYW5kIGNsb25lMy4gIElmIF9fY2xvbmUzIHJldHVybnMK KyAgIC0xIHdpdGggRU5PU1lTLCBmYWxsIGJhY2sgdG8gY2xvbmUgb3IgY2xvbmUyLiAgKi8KK2V4 dGVybiBpbnQgX19jbG9uZV9pbnRlcm5hbCAoc3RydWN0IGNsb25lX2FyZ3MgKl9fY2xfYXJncywK KwkJCSAgICAgaW50ICgqX19mdW5jKSAodm9pZCAqX19hcmcpLCB2b2lkICpfX2FyZyk7CisKKyNp Zm5kZWYgX0lTT01BQworbGliY19oaWRkZW5fcHJvdG8gKF9fY2xvbmUzKQorbGliY19oaWRkZW5f cHJvdG8gKF9fY2xvbmVfaW50ZXJuYWwpCisjZW5kaWYKKworI2VuZGlmCmRpZmYgLS1naXQgYS9u cHRsL2FsbG9jYXRlc3RhY2suYyBiL25wdGwvYWxsb2NhdGVzdGFjay5jCmluZGV4IDliZTZjNDI4 OTQuLmNmZTM3YTM0NDMgMTAwNjQ0Ci0tLSBhL25wdGwvYWxsb2NhdGVzdGFjay5jCisrKyBiL25w dGwvYWxsb2NhdGVzdGFjay5jCkBAIC0zMyw0NyArMzMsNiBAQAogI2luY2x1ZGUgPGtlcm5lbC1m ZWF0dXJlcy5oPgogI2luY2x1ZGUgPG5wdGwtc3RhY2suaD4KIAotI2lmbmRlZiBORUVEX1NFUEFS QVRFX1JFR0lTVEVSX1NUQUNLCi0KLS8qIE1vc3QgYXJjaGl0ZWN0dXJlcyBoYXZlIGV4YWN0bHkg b25lIHN0YWNrIHBvaW50ZXIuICBTb21lIGhhdmUgbW9yZS4gICovCi0jIGRlZmluZSBTVEFDS19W QVJJQUJMRVMgdm9pZCAqc3RhY2thZGRyID0gTlVMTAotCi0vKiBIb3cgdG8gcGFzcyB0aGUgdmFs dWVzIHRvIHRoZSAnY3JlYXRlX3RocmVhZCcgZnVuY3Rpb24uICAqLwotIyBkZWZpbmUgU1RBQ0tf VkFSSUFCTEVTX0FSR1Mgc3RhY2thZGRyCi0KLS8qIEhvdyB0byBkZWNsYXJlIGZ1bmN0aW9uIHdo aWNoIGdldHMgdGhlcmUgcGFyYW1ldGVycy4gICovCi0jIGRlZmluZSBTVEFDS19WQVJJQUJMRVNf UEFSTVMgdm9pZCAqc3RhY2thZGRyCi0KLS8qIEhvdyB0byBkZWNsYXJlIGFsbG9jYXRlX3N0YWNr LiAgKi8KLSMgZGVmaW5lIEFMTE9DQVRFX1NUQUNLX1BBUk1TIHZvaWQgKipzdGFjawotCi0vKiBU aGlzIGlzIGhvdyB0aGUgZnVuY3Rpb24gaXMgY2FsbGVkLiAgV2UgZG8gaXQgdGhpcyB3YXkgdG8g YWxsb3cKLSAgIG90aGVyIHZhcmlhbnRzIG9mIHRoZSBmdW5jdGlvbiB0byBoYXZlIG1vcmUgcGFy YW1ldGVycy4gICovCi0jIGRlZmluZSBBTExPQ0FURV9TVEFDSyhhdHRyLCBwZCkgYWxsb2NhdGVf c3RhY2sgKGF0dHIsIHBkLCAmc3RhY2thZGRyKQotCi0jZWxzZQotCi0vKiBXZSBuZWVkIHR3byBz dGFja3MuICBUaGUga2VybmVsIHdpbGwgcGxhY2UgdGhlbSBidXQgd2UgaGF2ZSB0byB0ZWxsCi0g ICB0aGUga2VybmVsIGFib3V0IHRoZSBzaXplIG9mIHRoZSByZXNlcnZlZCBhZGRyZXNzIHNwYWNl LiAgKi8KLSMgZGVmaW5lIFNUQUNLX1ZBUklBQkxFUyB2b2lkICpzdGFja2FkZHIgPSBOVUxMOyBz aXplX3Qgc3RhY2tzaXplID0gMAotCi0vKiBIb3cgdG8gcGFzcyB0aGUgdmFsdWVzIHRvIHRoZSAn Y3JlYXRlX3RocmVhZCcgZnVuY3Rpb24uICAqLwotIyBkZWZpbmUgU1RBQ0tfVkFSSUFCTEVTX0FS R1Mgc3RhY2thZGRyLCBzdGFja3NpemUKLQotLyogSG93IHRvIGRlY2xhcmUgZnVuY3Rpb24gd2hp Y2ggZ2V0cyB0aGVyZSBwYXJhbWV0ZXJzLiAgKi8KLSMgZGVmaW5lIFNUQUNLX1ZBUklBQkxFU19Q QVJNUyB2b2lkICpzdGFja2FkZHIsIHNpemVfdCBzdGFja3NpemUKLQotLyogSG93IHRvIGRlY2xh cmUgYWxsb2NhdGVfc3RhY2suICAqLwotIyBkZWZpbmUgQUxMT0NBVEVfU1RBQ0tfUEFSTVMgdm9p ZCAqKnN0YWNrLCBzaXplX3QgKnN0YWNrc2l6ZQotCi0vKiBUaGlzIGlzIGhvdyB0aGUgZnVuY3Rp b24gaXMgY2FsbGVkLiAgV2UgZG8gaXQgdGhpcyB3YXkgdG8gYWxsb3cKLSAgIG90aGVyIHZhcmlh bnRzIG9mIHRoZSBmdW5jdGlvbiB0byBoYXZlIG1vcmUgcGFyYW1ldGVycy4gICovCi0jIGRlZmlu ZSBBTExPQ0FURV9TVEFDSyhhdHRyLCBwZCkgXAotICBhbGxvY2F0ZV9zdGFjayAoYXR0ciwgcGQs ICZzdGFja2FkZHIsICZzdGFja3NpemUpCi0KLSNlbmRpZgotCi0KIC8qIERlZmF1bHQgYWxpZ25t ZW50IG9mIHN0YWNrLiAgKi8KICNpZm5kZWYgU1RBQ0tfQUxJR04KICMgZGVmaW5lIFNUQUNLX0FM SUdOIF9fYWxpZ25vZl9fIChsb25nIGRvdWJsZSkKQEAgLTI1Miw3ICsyMTEsNyBAQCBhZHZpc2Vf c3RhY2tfcmFuZ2UgKHZvaWQgKm1lbSwgc2l6ZV90IHNpemUsIHVpbnRwdHJfdCBwZCwgc2l6ZV90 IGd1YXJkc2l6ZSkKICAgIFBEUCBtdXN0IGJlIG5vbi1OVUxMLiAgKi8KIHN0YXRpYyBpbnQKIGFs bG9jYXRlX3N0YWNrIChjb25zdCBzdHJ1Y3QgcHRocmVhZF9hdHRyICphdHRyLCBzdHJ1Y3QgcHRo cmVhZCAqKnBkcCwKLQkJQUxMT0NBVEVfU1RBQ0tfUEFSTVMpCisJCXZvaWQgKipzdGFjaywgc2l6 ZV90ICpzdGFja3NpemUpCiB7CiAgIHN0cnVjdCBwdGhyZWFkICpwZDsKICAgc2l6ZV90IHNpemU7 CkBAIC02MDMsMjUgKzU2MiwxNyBAQCBhbGxvY2F0ZV9zdGFjayAoY29uc3Qgc3RydWN0IHB0aHJl YWRfYXR0ciAqYXR0ciwgc3RydWN0IHB0aHJlYWQgKipwZHAsCiAgIC8qIFdlIHBsYWNlIHRoZSB0 aHJlYWQgZGVzY3JpcHRvciBhdCB0aGUgZW5kIG9mIHRoZSBzdGFjay4gICovCiAgICpwZHAgPSBw ZDsKIAotI2lmIF9TVEFDS19HUk9XU19ET1dOCiAgIHZvaWQgKnN0YWNrdG9wOwogCi0jIGlmIFRM U19UQ0JfQVRfVFAKKyNpZiBUTFNfVENCX0FUX1RQCiAgIC8qIFRoZSBzdGFjayBiZWdpbnMgYmVm b3JlIHRoZSBUQ0IgYW5kIHRoZSBzdGF0aWMgVExTIGJsb2NrLiAgKi8KICAgc3RhY2t0b3AgPSAo KGNoYXIgKikgKHBkICsgMSkgLSB0bHNfc3RhdGljX3NpemVfZm9yX3N0YWNrKTsKLSMgZWxpZiBU TFNfRFRWX0FUX1RQCisjZWxpZiBUTFNfRFRWX0FUX1RQCiAgIHN0YWNrdG9wID0gKGNoYXIgKikg KHBkIC0gMSk7Ci0jIGVuZGlmCisjZW5kaWYKIAotIyBpZmRlZiBORUVEX1NFUEFSQVRFX1JFR0lT VEVSX1NUQUNLCisgICpzdGFja3NpemUgPSBzdGFja3RvcCAtIHBkLT5zdGFja2Jsb2NrOwogICAq c3RhY2sgPSBwZC0+c3RhY2tibG9jazsKLSAgKnN0YWNrc2l6ZSA9IHN0YWNrdG9wIC0gKnN0YWNr OwotIyBlbHNlCi0gICpzdGFjayA9IHN0YWNrdG9wOwotIyBlbmRpZgotI2Vsc2UKLSAgKnN0YWNr ID0gcGQtPnN0YWNrYmxvY2s7Ci0jZW5kaWYKIAogICByZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBh L25wdGwvcHRocmVhZF9jcmVhdGUuYyBiL25wdGwvcHRocmVhZF9jcmVhdGUuYwppbmRleCA0NDBh ZGMyYTZmLi5kOGVjMjk5Y2IxIDEwMDY0NAotLS0gYS9ucHRsL3B0aHJlYWRfY3JlYXRlLmMKKysr IGIvbnB0bC9wdGhyZWFkX2NyZWF0ZS5jCkBAIC0zNiw2ICszNiw3IEBACiAjaW5jbHVkZSAibGli aW9QLmgiCiAjaW5jbHVkZSA8c3lzL3NpbmdsZV90aHJlYWRlZC5oPgogI2luY2x1ZGUgPHZlcnNp b24uaD4KKyNpbmNsdWRlIDxjbG9uZV9pbnRlcm5hbC5oPgogCiAjaW5jbHVkZSA8c2hsaWItY29t cGF0Lmg+CiAKQEAgLTIyNyw4ICsyMjgsOCBAQCBsYXRlX2luaXQgKHZvaWQpCiBzdGF0aWMgaW50 IF9Ob3JldHVybiBzdGFydF90aHJlYWQgKHZvaWQgKmFyZyk7CiAKIHN0YXRpYyBpbnQgY3JlYXRl X3RocmVhZCAoc3RydWN0IHB0aHJlYWQgKnBkLCBjb25zdCBzdHJ1Y3QgcHRocmVhZF9hdHRyICph dHRyLAotCQkJICBib29sICpzdG9wcGVkX3N0YXJ0LCBTVEFDS19WQVJJQUJMRVNfUEFSTVMsCi0J CQkgIGJvb2wgKnRocmVhZF9yYW4pCisJCQkgIGJvb2wgKnN0b3BwZWRfc3RhcnQsIHZvaWQgKnN0 YWNrYWRkciwKKwkJCSAgc2l6ZV90IHN0YWNrc2l6ZSwgYm9vbCAqdGhyZWFkX3JhbikKIHsKICAg LyogRGV0ZXJtaW5lIHdoZXRoZXIgdGhlIG5ld2x5IGNyZWF0ZWQgdGhyZWFkcyBoYXMgdG8gYmUg c3RhcnRlZAogICAgICBzdG9wcGVkIHNpbmNlIHdlIGhhdmUgdG8gc2V0IHRoZSBzY2hlZHVsaW5n IHBhcmFtZXRlcnMgb3Igc2V0IHRoZQpAQCAtMjgwLDE0ICsyODEsMTggQEAgc3RhdGljIGludCBj cmVhdGVfdGhyZWFkIChzdHJ1Y3QgcHRocmVhZCAqcGQsIGNvbnN0IHN0cnVjdCBwdGhyZWFkX2F0 dHIgKmF0dHIsCiAKICAgVExTX0RFRklORV9JTklUX1RQICh0cCwgcGQpOwogCi0jaWZkZWYgX19O Ul9jbG9uZTIKLSMgZGVmaW5lIEFSQ0hfQ0xPTkUgX19jbG9uZTIKLSNlbHNlCi0jIGRlZmluZSBB UkNIX0NMT05FIF9fY2xvbmUKLSNlbmRpZgotICBpZiAoX19nbGliY191bmxpa2VseSAoQVJDSF9D TE9ORSAoJnN0YXJ0X3RocmVhZCwgU1RBQ0tfVkFSSUFCTEVTX0FSR1MsCi0JCQkJICAgIGNsb25l X2ZsYWdzLCBwZCwgJnBkLT50aWQsIHRwLCAmcGQtPnRpZCkKLQkJCT09IC0xKSkKKyAgc3RydWN0 IGNsb25lX2FyZ3MgYXJncyA9CisgICAgeworICAgICAgLmZsYWdzID0gY2xvbmVfZmxhZ3MsCisg ICAgICAucGlkZmQgPSAodWludHB0cl90KSAmcGQtPnRpZCwKKyAgICAgIC5wYXJlbnRfdGlkID0g KHVpbnRwdHJfdCkgJnBkLT50aWQsCisgICAgICAuY2hpbGRfdGlkID0gKHVpbnRwdHJfdCkgJnBk LT50aWQsCisgICAgICAuc3RhY2sgPSAodWludHB0cl90KSBzdGFja2FkZHIsCisgICAgICAuc3Rh Y2tfc2l6ZSA9IHN0YWNrc2l6ZSwKKyAgICAgIC50bHMgPSAodWludHB0cl90KSB0cCwKKyAgICB9 OworICBpbnQgcmV0ID0gX19jbG9uZV9pbnRlcm5hbCAoJmFyZ3MsICZzdGFydF90aHJlYWQsIHBk KTsKKyAgaWYgKF9fZ2xpYmNfdW5saWtlbHkgKHJldCA9PSAtMSkpCiAgICAgcmV0dXJuIGVycm5v OwogCiAgIC8qIEl0J3Mgc3RhcnRlZCBub3csIHNvIGlmIHdlIGZhaWwgYmVsb3csIHdlJ2xsIGhh dmUgdG8gbGV0IGl0IGNsZWFuIGl0c2VsZgpAQCAtNTc2LDcgKzU4MSw4IEBAIGludAogX19wdGhy ZWFkX2NyZWF0ZV8yXzEgKHB0aHJlYWRfdCAqbmV3dGhyZWFkLCBjb25zdCBwdGhyZWFkX2F0dHJf dCAqYXR0ciwKIAkJICAgICAgdm9pZCAqKCpzdGFydF9yb3V0aW5lKSAodm9pZCAqKSwgdm9pZCAq YXJnKQogewotICBTVEFDS19WQVJJQUJMRVM7CisgIHZvaWQgKnN0YWNrYWRkciA9IE5VTEw7Cisg IHNpemVfdCBzdGFja3NpemUgPSAwOwogCiAgIC8qIEF2b2lkIGEgZGF0YSByYWNlIGluIHRoZSBt dWx0aS10aHJlYWRlZCBjYXNlLCBhbmQgY2FsbCB0aGUKICAgICAgZGVmZXJyZWQgaW5pdGlhbGl6 YXRpb24gb25seSBvbmNlLiAgKi8KQEAgLTYwMCw3ICs2MDYsNyBAQCBfX3B0aHJlYWRfY3JlYXRl XzJfMSAocHRocmVhZF90ICpuZXd0aHJlYWQsIGNvbnN0IHB0aHJlYWRfYXR0cl90ICphdHRyLAog ICAgIH0KIAogICBzdHJ1Y3QgcHRocmVhZCAqcGQgPSBOVUxMOwotICBpbnQgZXJyID0gQUxMT0NB VEVfU1RBQ0sgKGlhdHRyLCAmcGQpOworICBpbnQgZXJyID0gYWxsb2NhdGVfc3RhY2sgKGlhdHRy LCAmcGQsICZzdGFja2FkZHIsICZzdGFja3NpemUpOwogICBpbnQgcmV0dmFsID0gMDsKIAogICBp ZiAoX19nbGliY191bmxpa2VseSAoZXJyICE9IDApKQpAQCAtNzQ0LDggKzc1MCw4IEBAIF9fcHRo cmVhZF9jcmVhdGVfMl8xIChwdGhyZWFkX3QgKm5ld3RocmVhZCwgY29uc3QgcHRocmVhZF9hdHRy X3QgKmF0dHIsCiAKICAgICAgIC8qIFdlIGFsd2F5cyBjcmVhdGUgdGhlIHRocmVhZCBzdG9wcGVk IGF0IHN0YXJ0dXAgc28gd2UgY2FuCiAJIG5vdGlmeSB0aGUgZGVidWdnZXIuICAqLwotICAgICAg cmV0dmFsID0gY3JlYXRlX3RocmVhZCAocGQsIGlhdHRyLCAmc3RvcHBlZF9zdGFydCwKLQkJCSAg ICAgIFNUQUNLX1ZBUklBQkxFU19BUkdTLCAmdGhyZWFkX3Jhbik7CisgICAgICByZXR2YWwgPSBj cmVhdGVfdGhyZWFkIChwZCwgaWF0dHIsICZzdG9wcGVkX3N0YXJ0LCBzdGFja2FkZHIsCisJCQkg ICAgICBzdGFja3NpemUsICZ0aHJlYWRfcmFuKTsKICAgICAgIGlmIChyZXR2YWwgPT0gMCkKIAl7 CiAJICAvKiBXZSByZXRhaW4gb3duZXJzaGlwIG9mIFBEIHVudGlsIChhKSAoc2VlIENPTkNVUlJF TkNZIE5PVEVTCkBAIC03NzYsOCArNzgyLDggQEAgX19wdGhyZWFkX2NyZWF0ZV8yXzEgKHB0aHJl YWRfdCAqbmV3dGhyZWFkLCBjb25zdCBwdGhyZWFkX2F0dHJfdCAqYXR0ciwKIAl9CiAgICAgfQog ICBlbHNlCi0gICAgcmV0dmFsID0gY3JlYXRlX3RocmVhZCAocGQsIGlhdHRyLCAmc3RvcHBlZF9z dGFydCwKLQkJCSAgICBTVEFDS19WQVJJQUJMRVNfQVJHUywgJnRocmVhZF9yYW4pOworICAgIHJl dHZhbCA9IGNyZWF0ZV90aHJlYWQgKHBkLCBpYXR0ciwgJnN0b3BwZWRfc3RhcnQsIHN0YWNrYWRk ciwKKwkJCSAgICBzdGFja3NpemUsICZ0aHJlYWRfcmFuKTsKIAogICAvKiBSZXR1cm4gdG8gdGhl IHByZXZpb3VzIHNpZ25hbCBtYXNrLCBhZnRlciBjcmVhdGluZyB0aGUgbmV3CiAgICAgIHRocmVh ZC4gICovCmRpZmYgLS1naXQgYS9zeXNkZXBzL3VuaXgvc3lzdi9saW51eC9NYWtlZmlsZSBiL3N5 c2RlcHMvdW5peC9zeXN2L2xpbnV4L01ha2VmaWxlCmluZGV4IGZlYjhmZDRjZTEuLmVkMGMwZDI3 ZjQgMTAwNjQ0Ci0tLSBhL3N5c2RlcHMvdW5peC9zeXN2L2xpbnV4L01ha2VmaWxlCisrKyBiL3N5 c2RlcHMvdW5peC9zeXN2L2xpbnV4L01ha2VmaWxlCkBAIC02NSw3ICs2NSw4IEBAIHN5c2RlcF9y b3V0aW5lcyArPSBhZGp0aW1leCBjbG9uZSB1bW91bnQgdW1vdW50MiByZWFkYWhlYWQgc3lzY3Rs IFwKIAkJICAgeHN0YXQgZnhzdGF0IGx4c3RhdCB4c3RhdDY0IGZ4c3RhdDY0IGx4c3RhdDY0IFwK IAkJICAgZnhzdGF0YXQgZnhzdGF0YXQ2NCBcCiAJCSAgIHhta25vZCB4bWtub2RhdCBjb252ZXJ0 X3NjbV90aW1lc3RhbXBzIFwKLQkJICAgY2xvc2Vmcm9tX2ZhbGxiYWNrCisJCSAgIGNsb3NlZnJv bV9mYWxsYmFjayBcCisJCSAgIGNsb25lMyBjbG9uZS1pbnRlcm5hbAogCiBDRkxBR1MtZ2V0aG9z dGlkLmMgPSAtZmV4Y2VwdGlvbnMKIENGTEFHUy10ZWUuYyA9IC1mZXhjZXB0aW9ucyAtZmFzeW5j aHJvbm91cy11bndpbmQtdGFibGVzCmRpZmYgLS1naXQgYS9zeXNkZXBzL3VuaXgvc3lzdi9saW51 eC9jbG9uZS1pbnRlcm5hbC5jIGIvc3lzZGVwcy91bml4L3N5c3YvbGludXgvY2xvbmUtaW50ZXJu YWwuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwLi4xZTdhOGY2YjM1Ci0t LSAvZGV2L251bGwKKysrIGIvc3lzZGVwcy91bml4L3N5c3YvbGludXgvY2xvbmUtaW50ZXJuYWwu YwpAQCAtMCwwICsxLDkxIEBACisvKiBUaGUgaW50ZXJuYWwgd3JhcHBlciBvZiBjbG9uZSBhbmQg Y2xvbmUzLgorICAgQ29weXJpZ2h0IChDKSAyMDIxIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwg SW5jLgorICAgVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEdOVSBDIExpYnJhcnkuCisKKyAgIFRo ZSBHTlUgQyBMaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgorICAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBH ZW5lcmFsIFB1YmxpYworICAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbjsgZWl0aGVyCisgICB2ZXJzaW9uIDIuMSBvZiB0aGUgTGljZW5zZSwgb3Ig KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgVGhlIEdOVSBDIExpYnJh cnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAg IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCisgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBV UlBPU0UuICBTZWUgdGhlIEdOVQorICAgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9y IG1vcmUgZGV0YWlscy4KKworICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICAgTGljZW5zZSBhbG9uZyB3aXRoIHRoZSBH TlUgQyBMaWJyYXJ5LiAgSWYgbm90LCBzZWUKKyAgIDxodHRwczovL3d3dy5nbnUub3JnL2xpY2Vu c2VzLz4uICAqLworCisjaW5jbHVkZSA8c3lzZGVwLmg+CisjaW5jbHVkZSA8c3RkZGVmLmg+Cisj aW5jbHVkZSA8ZXJybm8uaD4KKyNpbmNsdWRlIDxzY2hlZC5oPgorI2luY2x1ZGUgPGNsb25lX2lu dGVybmFsLmg+CisjaW5jbHVkZSA8bGliYy1wb2ludGVyLWFyaXRoLmg+CS8qIEZvciBjYXN0X3Rv X3BvaW50ZXIuICAqLworI2luY2x1ZGUgPHN0YWNraW5mby5oPgkJLyogRm9yIF9TVEFDS19HUk9X U197VVAsRE9XTn0uICAqLworCisjZGVmaW5lIENMT05FX0FSR1NfU0laRV9WRVIwIDY0IC8qIHNp emVvZiBmaXJzdCBwdWJsaXNoZWQgc3RydWN0ICovCisjZGVmaW5lIENMT05FX0FSR1NfU0laRV9W RVIxIDgwIC8qIHNpemVvZiBzZWNvbmQgcHVibGlzaGVkIHN0cnVjdCAqLworI2RlZmluZSBDTE9O RV9BUkdTX1NJWkVfVkVSMiA4OCAvKiBzaXplb2YgdGhpcmQgcHVibGlzaGVkIHN0cnVjdCAqLwor CisjZGVmaW5lIHNpemVvZl9maWVsZChUWVBFLCBNRU1CRVIpIHNpemVvZiAoKCgoVFlQRSAqKTAp LT5NRU1CRVIpKQorI2RlZmluZSBvZmZzZXRvZmVuZChUWVBFLCBNRU1CRVIpIFwKKyAgKG9mZnNl dG9mIChUWVBFLCBNRU1CRVIpICsgc2l6ZW9mX2ZpZWxkIChUWVBFLCBNRU1CRVIpKQorCitfU3Rh dGljX2Fzc2VydCAoX19hbGlnbm9mIChzdHJ1Y3QgY2xvbmVfYXJncykgPT0gOCwKKwkJIl9fYWxp Z25vZiAoc3RydWN0IGNsb25lX2FyZ3MpICE9IDgiKTsKK19TdGF0aWNfYXNzZXJ0IChvZmZzZXRv ZmVuZCAoc3RydWN0IGNsb25lX2FyZ3MsIHRscykgPT0gQ0xPTkVfQVJHU19TSVpFX1ZFUjAsCisJ CSJvZmZzZXRvZmVuZCAoc3RydWN0IGNsb25lX2FyZ3MsIHRscykgIT0gQ0xPTkVfQVJHU19TSVpF X1ZFUjAiKTsKK19TdGF0aWNfYXNzZXJ0IChvZmZzZXRvZmVuZCAoc3RydWN0IGNsb25lX2FyZ3Ms IHNldF90aWRfc2l6ZSkgPT0gQ0xPTkVfQVJHU19TSVpFX1ZFUjEsCisJCSJvZmZzZXRvZmVuZCAo c3RydWN0IGNsb25lX2FyZ3MsIHNldF90aWRfc2l6ZSkgIT0gQ0xPTkVfQVJHU19TSVpFX1ZFUjEi KTsKK19TdGF0aWNfYXNzZXJ0IChvZmZzZXRvZmVuZCAoc3RydWN0IGNsb25lX2FyZ3MsIGNncm91 cCkgPT0gQ0xPTkVfQVJHU19TSVpFX1ZFUjIsCisJCSJvZmZzZXRvZmVuZCAoc3RydWN0IGNsb25l X2FyZ3MsIGNncm91cCkgIT0gQ0xPTkVfQVJHU19TSVpFX1ZFUjIiKTsKK19TdGF0aWNfYXNzZXJ0 IChzaXplb2YgKHN0cnVjdCBjbG9uZV9hcmdzKSA9PSBDTE9ORV9BUkdTX1NJWkVfVkVSMiwKKwkJ InNpemVvZiAoc3RydWN0IGNsb25lX2FyZ3MpICE9IENMT05FX0FSR1NfU0laRV9WRVIyIik7CisK K2ludAorX19jbG9uZV9pbnRlcm5hbCAoc3RydWN0IGNsb25lX2FyZ3MgKmNsX2FyZ3MsCisJCSAg aW50ICgqZnVuYykgKHZvaWQgKmFyZyksIHZvaWQgKmFyZykKK3sKKyAgaW50IHJldDsKKyNpZmRl ZiBIQVZFX0NMT05FM19XQVBQRVIKKyAgLyogVHJ5IGNsb25lMyBmaXJzdC4gICovCisgIGludCBz YXZlZF9lcnJubyA9IGVycm5vOworICByZXQgPSBfX2Nsb25lMyAoY2xfYXJncywgc2l6ZW9mICgq Y2xfYXJncyksIGZ1bmMsIGFyZyk7CisgIGlmIChyZXQgIT0gLTEgfHwgZXJybm8gIT0gRU5PU1lT KQorICAgIHJldHVybiByZXQ7CisKKyAgLyogTkI6IFJlc3RvcmUgZXJybm8gc2luY2UgZXJybm8g bWF5IGJlIGNoZWNrZWQgYWdhaW5zdCBub24temVybworICAgICByZXR1cm4gdmFsdWUuICAqLwor ICBfX3NldF9lcnJubyAoc2F2ZWRfZXJybm8pOworI2VuZGlmCisKKyAgLyogTWFwIGNsb25lMyBh cmd1bWVudHMgdG8gY2xvbmUgYXJndW1lbnRzLiAgTkI6IE5vIG5lZWQgdG8gY2hlY2sKKyAgICAg aW52YWxpZCBjbG9uZTMgc3BlY2lmaWMgYml0cyBpbiBmbGFncyBub3IgZXhpdF9zaWduYWwgc2lu Y2UgdGhpcworICAgICBpcyBhbiBpbnRlcm5hbCBmdW5jdGlvbi4gICovCisgIGludCBmbGFncyA9 IGNsX2FyZ3MtPmZsYWdzIHwgY2xfYXJncy0+ZXhpdF9zaWduYWw7CisgIHZvaWQgKnN0YWNrID0g Y2FzdF90b19wb2ludGVyIChjbF9hcmdzLT5zdGFjayk7CisKKyNpZmRlZiBfX2lhNjRfXworICBy ZXQgPSBfX2Nsb25lMiAoZnVuYywgc3RhY2ssIGNsX2FyZ3MtPnN0YWNrX3NpemUsCisJCSAgZmxh Z3MsIGFyZywKKwkJICBjYXN0X3RvX3BvaW50ZXIgKGNsX2FyZ3MtPnBhcmVudF90aWQpLAorCQkg IGNhc3RfdG9fcG9pbnRlciAoY2xfYXJncy0+dGxzKSwKKwkJICBjYXN0X3RvX3BvaW50ZXIgKGNs X2FyZ3MtPmNoaWxkX3RpZCkpOworI2Vsc2UKKyMgaWYgIV9TVEFDS19HUk9XU19ET1dOICYmICFf U1RBQ0tfR1JPV1NfVVAKKyMgIGVycm9yICJEZWZpbmUgZWl0aGVyIF9TVEFDS19HUk9XU19ET1dO IG9yIF9TVEFDS19HUk9XU19VUCIKKyMgZW5kaWYKKworIyBpZiBfU1RBQ0tfR1JPV1NfRE9XTgor ICBzdGFjayArPSBjbF9hcmdzLT5zdGFja19zaXplOworIyBlbmRpZgorICByZXQgPSBfX2Nsb25l IChmdW5jLCBzdGFjaywgZmxhZ3MsIGFyZywKKwkJIGNhc3RfdG9fcG9pbnRlciAoY2xfYXJncy0+ cGFyZW50X3RpZCksCisJCSBjYXN0X3RvX3BvaW50ZXIgKGNsX2FyZ3MtPnRscyksCisJCSBjYXN0 X3RvX3BvaW50ZXIgKGNsX2FyZ3MtPmNoaWxkX3RpZCkpOworI2VuZGlmCisgIHJldHVybiByZXQ7 Cit9CisKK2xpYmNfaGlkZGVuX2RlZiAoX19jbG9uZV9pbnRlcm5hbCkKZGlmZiAtLWdpdCBhL3N5 c2RlcHMvdW5peC9zeXN2L2xpbnV4L2Nsb25lMy5jIGIvc3lzZGVwcy91bml4L3N5c3YvbGludXgv Y2xvbmUzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMC4uZGU5NjNlZjg5 ZAotLS0gL2Rldi9udWxsCisrKyBiL3N5c2RlcHMvdW5peC9zeXN2L2xpbnV4L2Nsb25lMy5jCkBA IC0wLDAgKzEgQEAKKy8qIEFuIGVtcHR5IHBsYWNlaG9sZGVyLiAgKi8KZGlmZiAtLWdpdCBhL3N5 c2RlcHMvdW5peC9zeXN2L2xpbnV4L2Nsb25lMy5oIGIvc3lzZGVwcy91bml4L3N5c3YvbGludXgv Y2xvbmUzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMC4uMWUzNWZmNjQy MgotLS0gL2Rldi9udWxsCisrKyBiL3N5c2RlcHMvdW5peC9zeXN2L2xpbnV4L2Nsb25lMy5oCkBA IC0wLDAgKzEsNjcgQEAKKy8qIFRoZSB3cmFwcGVyIG9mIGNsb25lMy4KKyAgIENvcHlyaWdodCAo QykgMjAyMSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4KKyAgIFRoaXMgZmlsZSBpcyBw YXJ0IG9mIHRoZSBHTlUgQyBMaWJyYXJ5LgorCisgICBUaGUgR05VIEMgTGlicmFyeSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAgIG1vZGlmeSBpdCB1 bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAgIExpY2Vu c2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgor ICAgdmVyc2lvbiAyLjEgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxh dGVyIHZlcnNpb24uCisKKyAgIFRoZSBHTlUgQyBMaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRo ZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFO VFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgTUVSQ0hBTlRBQklM SVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAg IExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisKKyAgIFlv dSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQ dWJsaWMKKyAgIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGUgR05VIEMgTGlicmFyeS4gIElmIG5vdCwg c2VlCisgICA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LiAgKi8KKworI2lmbmRlZiBf Q0xPTkUzX0gKKyNkZWZpbmUgX0NMT05FM19ICTEKKworI2luY2x1ZGUgPGZlYXR1cmVzLmg+Cisj aW5jbHVkZSA8c3RkZGVmLmg+CisjaW5jbHVkZSA8Yml0cy90eXBlcy5oPgorCitfX0JFR0lOX0RF Q0xTCisKKy8qIFRoZSB1bnNpZ25lZCA2NC1iaXQgYW5kIDgtYnl0ZSBhbGlnbmVkIGludGVnZXIg dHlwZS4gICovCit0eXBlZGVmIF9fVTY0X1RZUEUgX19hbGlnbmVkX3VpbnQ2NF90IF9fYXR0cmli dXRlX18gKChfX2FsaWduZWRfXyAoOCkpKTsKKworLyogVGhpcyBzdHJ1Y3Qgc2hvdWxkIG9ubHkg YmUgdXNlZCBpbiBhbiBhcmd1bWVudCB0byB0aGUgY2xvbmUzIHN5c3RlbQorICAgY2FsbCAoYWxv bmcgd2l0aCBpdHMgc2l6ZSBhcmd1bWVudCkuICBJdCBtYXkgYmUgZXh0ZW5kZWQgd2l0aCBuZXcK KyAgIGZpZWxkcyBpbiB0aGUgZnV0dXJlLiAgKi8KKworc3RydWN0IGNsb25lX2FyZ3MKK3sKKyAg LyogRmxhZ3MgYml0IG1hc2suICAqLworICBfX2FsaWduZWRfdWludDY0X3QgZmxhZ3M7CisgIC8q IFdoZXJlIHRvIHN0b3JlIFBJRCBmaWxlIGRlc2NyaXB0b3IgKHBpZF90ICopLiAgKi8KKyAgX19h bGlnbmVkX3VpbnQ2NF90IHBpZGZkOworICAvKiBXaGVyZSB0byBzdG9yZSBjaGlsZCBUSUQsIGlu IGNoaWxkJ3MgbWVtb3J5IChwaWRfdCAqKS4gICovCisgIF9fYWxpZ25lZF91aW50NjRfdCBjaGls ZF90aWQ7CisgIC8qIFdoZXJlIHRvIHN0b3JlIGNoaWxkIFRJRCwgaW4gcGFyZW50J3MgbWVtb3J5 IChpbnQgKikuICovCisgIF9fYWxpZ25lZF91aW50NjRfdCBwYXJlbnRfdGlkOworICAvKiBTaWdu YWwgdG8gZGVsaXZlciB0byBwYXJlbnQgb24gY2hpbGQgdGVybWluYXRpb24gKi8KKyAgX19hbGln bmVkX3VpbnQ2NF90IGV4aXRfc2lnbmFsOworICAvKiBUaGUgbG93ZXN0IGFkZHJlc3Mgb2Ygc3Rh Y2suICAqLworICBfX2FsaWduZWRfdWludDY0X3Qgc3RhY2s7CisgIC8qIFNpemUgb2Ygc3RhY2su ICAqLworICBfX2FsaWduZWRfdWludDY0X3Qgc3RhY2tfc2l6ZTsKKyAgLyogTG9jYXRpb24gb2Yg bmV3IFRMUy4gICovCisgIF9fYWxpZ25lZF91aW50NjRfdCB0bHM7CisgIC8qIFBvaW50ZXIgdG8g YSBwaWRfdCBhcnJheSAoc2luY2UgTGludXggNS41KS4gICovCisgIF9fYWxpZ25lZF91aW50NjRf dCBzZXRfdGlkOworICAvKiBOdW1iZXIgb2YgZWxlbWVudHMgaW4gc2V0X3RpZCAoc2luY2UgTGlu dXggNS41KS4gKi8KKyAgX19hbGlnbmVkX3VpbnQ2NF90IHNldF90aWRfc2l6ZTsKKyAgLyogRmls ZSBkZXNjcmlwdG9yIGZvciB0YXJnZXQgY2dyb3VwIG9mIGNoaWxkIChzaW5jZSBMaW51eCA1Ljcp LiAgKi8KKyAgX19hbGlnbmVkX3VpbnQ2NF90IGNncm91cDsKK307CisKKy8qIFRoZSB3cmFwcGVy IG9mIGNsb25lMy4gICovCitleHRlcm4gaW50IGNsb25lMyAoc3RydWN0IGNsb25lX2FyZ3MgKl9f Y2xfYXJncywgc2l6ZV90IF9fc2l6ZSwKKwkJICAgaW50ICgqX19mdW5jKSAodm9pZCAqX19hcmcp LCB2b2lkICpfX2FyZyk7CisKK19fRU5EX0RFQ0xTCisKKyNlbmRpZiAvKiBjbG9uZTMuaCAqLwpk aWZmIC0tZ2l0IGEvc3lzZGVwcy91bml4L3N5c3YvbGludXgvc3Bhd25pLmMgYi9zeXNkZXBzL3Vu aXgvc3lzdi9saW51eC9zcGF3bmkuYwppbmRleCBmN2U3MzUzYTA1Li42YjBiYWRlNGQ0IDEwMDY0 NAotLS0gYS9zeXNkZXBzL3VuaXgvc3lzdi9saW51eC9zcGF3bmkuYworKysgYi9zeXNkZXBzL3Vu aXgvc3lzdi9saW51eC9zcGF3bmkuYwpAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgPHNwYXdu X2ludC5oPgogI2luY2x1ZGUgPHN5c2RlcC5oPgogI2luY2x1ZGUgPHN5cy9yZXNvdXJjZS5oPgor I2luY2x1ZGUgPGNsb25lX2ludGVybmFsLmg+CiAKIC8qIFRoZSBMaW51eCBpbXBsZW1lbnRhdGlv biBvZiBwb3NpeF9zcGF3bntwfSB1c2VzIHRoZSBjbG9uZSBzeXNjYWxsIGRpcmVjdGx5CiAgICB3 aXRoIENMT05FX1ZNIGFuZCBDTE9ORV9WRk9SSyBmbGFncyBhbmQgYW4gYWxsb2NhdGVkIHN0YWNr LiAgVGhlIG5ldyBzdGFjawpAQCAtNTMsMjEgKzU0LDYgQEAKICAgIG5vcm1hbCBwcm9ncmFtIGV4 aXQgd2l0aCB0aGUgZXhpdCBjb2RlIDEyNy4gICovCiAjZGVmaW5lIFNQQVdOX0VSUk9SCTEyNwog Ci0jaWZkZWYgX19pYTY0X18KLSMgZGVmaW5lIENMT05FKF9fZm4sIF9fc3RhY2tiYXNlLCBfX3N0 YWNrc2l6ZSwgX19mbGFncywgX19hcmdzKSBcCi0gIF9fY2xvbmUyIChfX2ZuLCBfX3N0YWNrYmFz ZSwgX19zdGFja3NpemUsIF9fZmxhZ3MsIF9fYXJncywgMCwgMCwgMCkKLSNlbHNlCi0jIGRlZmlu ZSBDTE9ORShfX2ZuLCBfX3N0YWNrLCBfX3N0YWNrc2l6ZSwgX19mbGFncywgX19hcmdzKSBcCi0g IF9fY2xvbmUgKF9fZm4sIF9fc3RhY2ssIF9fZmxhZ3MsIF9fYXJncykKLSNlbmRpZgotCi0vKiBT aW5jZSBpYTY0IHdhbnRzIHRoZSBzdGFja2Jhc2Ugdy9jbG9uZTIsIHJlLXVzZSB0aGUgZ3Jvd3Mt dXAgbWFjcm8uICAqLwotI2lmIF9TVEFDS19HUk9XU19VUCB8fCBkZWZpbmVkIChfX2lhNjRfXykK LSMgZGVmaW5lIFNUQUNLKF9fc3RhY2ssIF9fc3RhY2tfc2l6ZSkgKF9fc3RhY2spCi0jZWxpZiBf U1RBQ0tfR1JPV1NfRE9XTgotIyBkZWZpbmUgU1RBQ0soX19zdGFjaywgX19zdGFja19zaXplKSAo X19zdGFjayArIF9fc3RhY2tfc2l6ZSkKLSNlbmRpZgotCiAKIHN0cnVjdCBwb3NpeF9zcGF3bl9h cmdzCiB7CkBAIC0zODIsOCArMzY4LDE0IEBAIF9fc3Bhd25peCAocGlkX3QgKiBwaWQsIGNvbnN0 IGNoYXIgKmZpbGUsCiAgICAgIG5lZWQgZm9yIENMT05FX1NFVFRMUy4gIEFsdGhvdWdoIHBhcmVu dCBhbmQgY2hpbGQgc2hhcmUgdGhlIHNhbWUgVExTCiAgICAgIG5hbWVzcGFjZSwgdGhlcmUgd2ls bCBiZSBubyBjb25jdXJyZW50IGFjY2VzcyBmb3IgVExTIHZhcmlhYmxlcyAoZXJybm8KICAgICAg Zm9yIGluc3RhbmNlKS4gICovCi0gIG5ld19waWQgPSBDTE9ORSAoX19zcGF3bmlfY2hpbGQsIFNU QUNLIChzdGFjaywgc3RhY2tfc2l6ZSksIHN0YWNrX3NpemUsCi0JCSAgIENMT05FX1ZNIHwgQ0xP TkVfVkZPUksgfCBTSUdDSExELCAmYXJncyk7CisgIHN0cnVjdCBjbG9uZV9hcmdzIGNsb25lX2Fy Z3MgPQorICAgIHsKKyAgICAgIC5mbGFncyA9IENMT05FX1ZNIHwgQ0xPTkVfVkZPUkssCisgICAg ICAuZXhpdF9zaWduYWwgPSBTSUdDSExELAorICAgICAgLnN0YWNrID0gKHVpbnRwdHJfdCkgc3Rh Y2ssCisgICAgICAuc3RhY2tfc2l6ZSA9IHN0YWNrX3NpemUsCisgICAgfTsKKyAgbmV3X3BpZCA9 IF9fY2xvbmVfaW50ZXJuYWwgKCZjbG9uZV9hcmdzLCBfX3NwYXduaV9jaGlsZCwgJmFyZ3MpOwog CiAgIC8qIEl0IG5lZWRzIHRvIGNvbGxlY3QgdGhlIGNhc2Ugd2hlcmUgdGhlIGF1eGlsaWFyeSBw cm9jZXNzIHdhcyBjcmVhdGVkCiAgICAgIGJ1dCBmYWlsZWQgdG8gZXhlY3V0ZSB0aGUgZmlsZSAo ZHVlIGVpdGhlciBhbnkgcHJlcGFyYXRpb24gc3RlcCBvcgotLSAKMi4zMS4xCgo= --00000000000095e83105c7068abc--