From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alex Belits Subject: [PATCH v2 03/12] task_isolation: userspace hard isolation from kernel Date: Sun, 8 Mar 2020 03:47:08 +0000 Message-ID: <105f17f25e90a9a58299a7ed644bdd0f36434c87.camel@marvell.com> References: <4473787e1b6bc3cc226067e8d122092a678b63de.camel@marvell.com> Mime-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Return-path: In-Reply-To: Content-Language: en-US Content-ID: <86098B5433923643954377077B047068@namprd18.prod.outlook.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=m.gmane-mx.org@lists.infradead.org To: "frederic@kernel.org" , "rostedt@goodmis.org" Cc: "linux-arch@vger.kernel.org" , "catalin.marinas@arm.com" , "peterz@infradead.org" , Prasun Kapoor , "linux-kernel@vger.kernel.org" , "davem@davemloft.net" , "netdev@vger.kernel.org" , "linux-api@vger.kernel.org" , "tglx@linutronix.de" , "will@kernel.org" , "mingo@kernel.org" , "linux-arm-kernel@lists.infradead.org" List-Id: linux-arch.vger.kernel.org The existing nohz_full mode is designed as a "soft" isolation mode that makes tradeoffs to minimize userspace interruptions while still attempting to avoid overheads in the kernel entry/exit path, to provide 100% kernel semantics, etc. However, some applications require a "hard" commitment from the kernel to avoid interruptions, in particular userspace device driver style applications, such as high-speed networking code. This change introduces a framework to allow applications to elect to have the "hard" semantics as needed, specifying prctl(PR_TASK_ISOLATION, PR_TASK_ISOLATION_ENABLE) to do so. The kernel must be built with the new TASK_ISOLATION Kconfig flag to enable this mode, and the kernel booted with an appropriate "isolcpus=nohz,domain,CPULIST" boot argument to enable nohz_full and isolcpus. The "task_isolation" state is then indicated by setting a new task struct field, task_isolation_flag, to the value passed by prctl(), and also setting a TIF_TASK_ISOLATION bit in the thread_info flags. When the kernel is returning to userspace from the prctl() call and sees TIF_TASK_ISOLATION set, it calls the new task_isolation_start() routine to arrange for the task to avoid being interrupted in the future. With interrupts disabled, task_isolation_start() ensures that kernel subsystems that might cause a future interrupt are quiesced. If it doesn't succeed, it adjusts the syscall return value to indicate that fact, and userspace can retry as desired. In addition to stopping the scheduler tick, the code takes any actions that might avoid a future interrupt to the core, such as a worker thread being scheduled that could be quiesced now (e.g. the vmstat worker) or a future IPI to the core to clean up some state that could be cleaned up now (e.g. the mm lru per-cpu cache). Once the task has returned to userspace after issuing the prctl(), if it enters the kernel again via system call, page fault, or any other exception or irq, the kernel will kill it with SIGKILL. In addition to sending a signal, the code supports a kernel command-line "task_isolation_debug" flag which causes a stack backtrace to be generated whenever a task loses isolation. To allow the state to be entered and exited, the syscall checking test ignores the prctl(PR_TASK_ISOLATION) syscall so that we can clear the bit again later, and ignores exit/exit_group to allow exiting the task without a pointless signal being delivered. The prctl() API allows for specifying a signal number to use instead of the default SIGKILL, to allow for catching the notification signal; for example, in a production environment, it might be helpful to log information to the application logging mechanism before exiting. Or, the signal handler might choose to reset the program counter back to the code segment intended to be run isolated via prctl() to continue execution. In a number of cases we can tell on a remote cpu that we are going to be interrupting the cpu, e.g. via an IPI or a TLB flush. In that case we generate the diagnostic (and optional stack dump) on the remote core to be able to deliver better diagnostics. If the interrupt is not something caught by Linux (e.g. a hypervisor interrupt) we can also request a reschedule IPI to be sent to the remote core so it can be sure to generate a signal to notify the process. Separate patches that follow provide these changes for x86, arm, and arm64. Signed-off-by: Alex Belits --- .../admin-guide/kernel-parameters.txt | 6 + include/linux/hrtimer.h | 4 + include/linux/isolation.h | 229 ++++++ include/linux/sched.h | 4 + include/linux/tick.h | 3 + include/uapi/linux/prctl.h | 6 + init/Kconfig | 28 + kernel/Makefile | 2 + kernel/context_tracking.c | 2 + kernel/isolation.c | 774 ++++++++++++++++++ kernel/signal.c | 2 + kernel/sys.c | 6 + kernel/time/hrtimer.c | 27 + kernel/time/tick-sched.c | 18 + 14 files changed, 1111 insertions(+) create mode 100644 include/linux/isolation.h create mode 100644 kernel/isolation.c diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt index c07815d230bc..e4a2d6e37645 100644 --- a/Documentation/admin-guide/kernel-parameters.txt +++ b/Documentation/admin-guide/kernel-parameters.txt @@ -4808,6 +4808,12 @@ neutralize any effect of /proc/sys/kernel/sysrq. Useful for debugging. + task_isolation_debug [KNL] + In kernels built with CONFIG_TASK_ISOLATION, this + setting will generate console backtraces to + accompany the diagnostics generated about + interrupting tasks running with task isolation. + tcpmhash_entries= [KNL,NET] Set the number of tcp_metrics_hash slots. Default value is 8192 or 16384 depending on total diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h index 15c8ac313678..e81252eb4f92 100644 --- a/include/linux/hrtimer.h +++ b/include/linux/hrtimer.h @@ -528,6 +528,10 @@ extern void __init hrtimers_init(void); /* Show pending timers: */ extern void sysrq_timer_list_show(void); +#ifdef CONFIG_TASK_ISOLATION +extern void kick_hrtimer(void); +#endif + int hrtimers_prepare_cpu(unsigned int cpu); #ifdef CONFIG_HOTPLUG_CPU int hrtimers_dead_cpu(unsigned int cpu); diff --git a/include/linux/isolation.h b/include/linux/isolation.h new file mode 100644 index 000000000000..6bd71c67f10f --- /dev/null +++ b/include/linux/isolation.h @@ -0,0 +1,229 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Task isolation support + * + * Authors: + * Chris Metcalf + * Alex Belits + * Yuri Norov + */ +#ifndef _LINUX_ISOLATION_H +#define _LINUX_ISOLATION_H + +#include +#include +#include +#include +#include + +struct task_struct; + +#ifdef CONFIG_TASK_ISOLATION + +int task_isolation_message(int cpu, int level, bool supp, const char *fmt, ...); + +#define pr_task_isol_emerg(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_EMERG, false, fmt, ##__VA_ARGS__) +#define pr_task_isol_alert(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_ALERT, false, fmt, ##__VA_ARGS__) +#define pr_task_isol_crit(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_CRIT, false, fmt, ##__VA_ARGS__) +#define pr_task_isol_err(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_ERR, false, fmt, ##__VA_ARGS__) +#define pr_task_isol_warn(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_WARNING, false, fmt, ##__VA_ARGS__) +#define pr_task_isol_notice(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_NOTICE, false, fmt, ##__VA_ARGS__) +#define pr_task_isol_info(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_INFO, false, fmt, ##__VA_ARGS__) +#define pr_task_isol_debug(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_DEBUG, false, fmt, ##__VA_ARGS__) + +#define pr_task_isol_emerg_supp(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_EMERG, true, fmt, ##__VA_ARGS__) +#define pr_task_isol_alert_supp(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_ALERT, true, fmt, ##__VA_ARGS__) +#define pr_task_isol_crit_supp(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_CRIT, true, fmt, ##__VA_ARGS__) +#define pr_task_isol_err_supp(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_ERR, true, fmt, ##__VA_ARGS__) +#define pr_task_isol_warn_supp(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_WARNING, true, fmt, ##__VA_ARGS__) +#define pr_task_isol_notice_supp(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_NOTICE, true, fmt, ##__VA_ARGS__) +#define pr_task_isol_info_supp(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_INFO, true, fmt, ##__VA_ARGS__) +#define pr_task_isol_debug_supp(cpu, fmt, ...) \ + task_isolation_message(cpu, LOGLEVEL_DEBUG, true, fmt, ##__VA_ARGS__) +DECLARE_PER_CPU(unsigned long, tsk_thread_flags_copy); +extern cpumask_var_t task_isolation_map; + +/** + * task_isolation_request() - prctl hook to request task isolation + * @flags: Flags from PR_TASK_ISOLATION_xxx. + * + * This is called from the generic prctl() code for PR_TASK_ISOLATION. + * + * Return: Returns 0 when task isolation enabled, otherwise a negative + * errno. + */ +extern int task_isolation_request(unsigned int flags); +extern void task_isolation_cpu_cleanup(void); +/** + * task_isolation_start() - attempt to actually start task isolation + * + * This function should be invoked as the last thing prior to returning to + * user space if TIF_TASK_ISOLATION is set in the thread_info flags. It + * will attempt to quiesce the core and enter task-isolation mode. If it + * fails, it will reset the system call return value to an error code that + * indicates the failure mode. + */ +extern void task_isolation_start(void); + +/** + * is_isolation_cpu() - check if CPU is intended for running isolated tasks. + * @cpu: CPU to check. + */ +static inline bool is_isolation_cpu(int cpu) +{ + return task_isolation_map != NULL && + cpumask_test_cpu(cpu, task_isolation_map); +} + +/** + * task_isolation_on_cpu() - check if the cpu is running isolated task + * @cpu: CPU to check. + */ +extern int task_isolation_on_cpu(int cpu); +extern void task_isolation_check_run_cleanup(void); + +/** + * task_isolation_cpumask() - set CPUs currently running isolated tasks + * @mask: Mask to modify. + */ +extern void task_isolation_cpumask(struct cpumask *mask); + +/** + * task_isolation_clear_cpumask() - clear CPUs currently running isolated tasks + * @mask: Mask to modify. + */ +extern void task_isolation_clear_cpumask(struct cpumask *mask); + +/** + * task_isolation_syscall() - report a syscall from an isolated task + * @nr: The syscall number. + * + * This routine should be invoked at syscall entry if TIF_TASK_ISOLATION is + * set in the thread_info flags. It checks for valid syscalls, + * specifically prctl() with PR_TASK_ISOLATION, exit(), and exit_group(). + * For any other syscall it will raise a signal and return failure. + * + * Return: 0 for acceptable syscalls, -1 for all others. + */ +extern int task_isolation_syscall(int nr); + +/** + * _task_isolation_interrupt() - report an interrupt of an isolated task + * @fmt: A format string describing the interrupt + * @...: Format arguments, if any. + * + * This routine should be invoked at any exception or IRQ if + * TIF_TASK_ISOLATION is set in the thread_info flags. It is not necessary + * to invoke it if the exception will generate a signal anyway (e.g. a bad + * page fault), and in that case it is preferable not to invoke it but just + * rely on the standard Linux signal. The macro task_isolation_syscall() + * wraps the TIF_TASK_ISOLATION flag test to simplify the caller code. + */ +extern void _task_isolation_interrupt(const char *fmt, ...); +#define task_isolation_interrupt(fmt, ...) \ + do { \ + if (current_thread_info()->flags & _TIF_TASK_ISOLATION) \ + _task_isolation_interrupt(fmt, ## __VA_ARGS__); \ + } while (0) + +/** + * task_isolation_remote() - report a remote interrupt of an isolated task + * @cpu: The remote cpu that is about to be interrupted. + * @fmt: A format string describing the interrupt + * @...: Format arguments, if any. + * + * This routine should be invoked any time a remote IPI or other type of + * interrupt is being delivered to another cpu. The function will check to + * see if the target core is running a task-isolation task, and generate a + * diagnostic on the console if so; in addition, we tag the task so it + * doesn't generate another diagnostic when the interrupt actually arrives. + * Generating a diagnostic remotely yields a clearer indication of what + * happened then just reporting only when the remote core is interrupted. + * + */ +extern void task_isolation_remote(int cpu, const char *fmt, ...); + +/** + * task_isolation_remote_cpumask() - report interruption of multiple cpus + * @mask: The set of remotes cpus that are about to be interrupted. + * @fmt: A format string describing the interrupt + * @...: Format arguments, if any. + * + * This is the cpumask variant of _task_isolation_remote(). We + * generate a single-line diagnostic message even if multiple remote + * task-isolation cpus are being interrupted. + */ +extern void task_isolation_remote_cpumask(const struct cpumask *mask, + const char *fmt, ...); + +/** + * _task_isolation_signal() - disable task isolation when signal is pending + * @task: The task for which to disable isolation. + * + * This function generates a diagnostic and disables task isolation; it + * should be called if TIF_TASK_ISOLATION is set when notifying a task of a + * pending signal. The task_isolation_interrupt() function normally + * generates a diagnostic for events that just interrupt a task without + * generating a signal; here we need to hook the paths that correspond to + * interrupts that do generate a signal. The macro task_isolation_signal() + * wraps the TIF_TASK_ISOLATION flag test to simplify the caller code. + */ +extern void _task_isolation_signal(struct task_struct *task); +#define task_isolation_signal(task) \ + do { \ + if (task_thread_info(task)->flags & _TIF_TASK_ISOLATION) \ + _task_isolation_signal(task); \ + } while (0) + +/** + * task_isolation_user_exit() - debug all user_exit calls + * + * By default, we don't generate an exception in the low-level user_exit() + * code, because programs lose the ability to disable task isolation: the + * user_exit() hook will cause a signal prior to task_isolation_syscall() + * disabling task isolation. In addition, it means that we lose all the + * diagnostic info otherwise available from task_isolation_interrupt() hooks + * later in the interrupt-handling process. But you may enable it here for + * a special kernel build if you are having undiagnosed userspace jitter. + */ +static inline void task_isolation_user_exit(void) +{ +#ifdef DEBUG_TASK_ISOLATION + task_isolation_interrupt("user_exit"); +#endif +} + +#else /* !CONFIG_TASK_ISOLATION */ +static inline int task_isolation_request(unsigned int flags) { return -EINVAL; } +static inline void task_isolation_start(void) { } +static inline bool is_isolation_cpu(int cpu) { return 0; } +static inline int task_isolation_on_cpu(int cpu) { return 0; } +static inline void task_isolation_cpumask(struct cpumask *mask) { } +static inline void task_isolation_clear_cpumask(struct cpumask *mask) { } +static inline void task_isolation_cpu_cleanup(void) { } +static inline void task_isolation_check_run_cleanup(void) { } +static inline int task_isolation_syscall(int nr) { return 0; } +static inline void task_isolation_interrupt(const char *fmt, ...) { } +static inline void task_isolation_remote(int cpu, const char *fmt, ...) { } +static inline void task_isolation_remote_cpumask(const struct cpumask *mask, + const char *fmt, ...) { } +static inline void task_isolation_signal(struct task_struct *task) { } +static inline void task_isolation_user_exit(void) { } +#endif + +#endif /* _LINUX_ISOLATION_H */ diff --git a/include/linux/sched.h b/include/linux/sched.h index 04278493bf15..52fdb32aa3b9 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -1280,6 +1280,10 @@ struct task_struct { unsigned long lowest_stack; unsigned long prev_lowest_stack; #endif +#ifdef CONFIG_TASK_ISOLATION + unsigned short task_isolation_flags; /* prctl */ + unsigned short task_isolation_state; +#endif /* * New fields for task_struct should be added above here, so that diff --git a/include/linux/tick.h b/include/linux/tick.h index 7340613c7eff..27c7c033d5a8 100644 --- a/include/linux/tick.h +++ b/include/linux/tick.h @@ -268,6 +268,9 @@ static inline void tick_dep_clear_signal(struct signal_struct *signal, extern void tick_nohz_full_kick_cpu(int cpu); extern void __tick_nohz_task_switch(void); extern void __init tick_nohz_full_setup(cpumask_var_t cpumask); +#ifdef CONFIG_TASK_ISOLATION +extern int try_stop_full_tick(void); +#endif #else static inline bool tick_nohz_full_enabled(void) { return false; } static inline bool tick_nohz_full_cpu(int cpu) { return false; } diff --git a/include/uapi/linux/prctl.h b/include/uapi/linux/prctl.h index 07b4f8131e36..f4848ed2a069 100644 --- a/include/uapi/linux/prctl.h +++ b/include/uapi/linux/prctl.h @@ -238,4 +238,10 @@ struct prctl_mm_map { #define PR_SET_IO_FLUSHER 57 #define PR_GET_IO_FLUSHER 58 +/* Enable task_isolation mode for TASK_ISOLATION kernels. */ +#define PR_TASK_ISOLATION 48 +# define PR_TASK_ISOLATION_ENABLE (1 << 0) +# define PR_TASK_ISOLATION_SET_SIG(sig) (((sig) & 0x7f) << 8) +# define PR_TASK_ISOLATION_GET_SIG(bits) (((bits) >> 8) & 0x7f) + #endif /* _LINUX_PRCTL_H */ diff --git a/init/Kconfig b/init/Kconfig index 20a6ac33761c..ecdf567f6bd4 100644 --- a/init/Kconfig +++ b/init/Kconfig @@ -576,6 +576,34 @@ config CPU_ISOLATION source "kernel/rcu/Kconfig" +config HAVE_ARCH_TASK_ISOLATION + bool + +config TASK_ISOLATION + bool "Provide hard CPU isolation from the kernel on demand" + depends on NO_HZ_FULL && HAVE_ARCH_TASK_ISOLATION + help + + Allow userspace processes that place themselves on cores with + nohz_full and isolcpus enabled, and run prctl(PR_TASK_ISOLATION), + to "isolate" themselves from the kernel. Prior to returning to + userspace, isolated tasks will arrange that no future kernel + activity will interrupt the task while the task is running in + userspace. Attempting to re-enter the kernel while in this mode + will cause the task to be terminated with a signal; you must + explicitly use prctl() to disable task isolation before resuming + normal use of the kernel. + + This "hard" isolation from the kernel is required for userspace + tasks that are running hard real-time tasks in userspace, such as + a high-speed network driver in userspace. Without this option, but + with NO_HZ_FULL enabled, the kernel will make a best-faith, "soft" + effort to shield a single userspace process from interrupts, but + makes no guarantees. + + You should say "N" unless you are intending to run a + high-performance userspace driver or similar task. + config BUILD_BIN2C bool default n diff --git a/kernel/Makefile b/kernel/Makefile index 4cb4130ced32..2f2ae91f90d5 100644 --- a/kernel/Makefile +++ b/kernel/Makefile @@ -122,6 +122,8 @@ obj-$(CONFIG_GCC_PLUGIN_STACKLEAK) += stackleak.o KASAN_SANITIZE_stackleak.o := n KCOV_INSTRUMENT_stackleak.o := n +obj-$(CONFIG_TASK_ISOLATION) += isolation.o + $(obj)/configs.o: $(obj)/config_data.gz targets += config_data.gz diff --git a/kernel/context_tracking.c b/kernel/context_tracking.c index 0296b4bda8f1..e9206736f219 100644 --- a/kernel/context_tracking.c +++ b/kernel/context_tracking.c @@ -21,6 +21,7 @@ #include #include #include +#include #define CREATE_TRACE_POINTS #include @@ -157,6 +158,7 @@ void __context_tracking_exit(enum ctx_state state) if (state == CONTEXT_USER) { vtime_user_exit(current); trace_user_exit(0); + task_isolation_user_exit(); } } __this_cpu_write(context_tracking.state, CONTEXT_KERNEL); diff --git a/kernel/isolation.c b/kernel/isolation.c new file mode 100644 index 000000000000..ae29732c376c --- /dev/null +++ b/kernel/isolation.c @@ -0,0 +1,774 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * linux/kernel/isolation.c + * + * Implementation of task isolation. + * + * Authors: + * Chris Metcalf + * Alex Belits + * Yuri Norov + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * These values are stored in task_isolation_state. + * Note that STATE_NORMAL + TIF_TASK_ISOLATION means we are still + * returning from sys_prctl() to userspace. + */ +enum { + STATE_NORMAL = 0, /* Not isolated */ + STATE_ISOLATED = 1 /* In userspace, isolated */ +}; + +/* + * This variable contains thread flags copied at the moment + * when schedule() switched to the task on a given CPU, + * or 0 if no task is running. + */ +DEFINE_PER_CPU(unsigned long, tsk_thread_flags_cache); + +/* + * Counter for isolation state on a given CPU, increments when entering + * isolation and decrements when exiting isolation (before or after the + * cleanup). Multiple simultaneously running procedures entering or + * exiting isolation are prevented by checking the result of + * incrementing or decrementing this variable. This variable is both + * incremented and decremented by CPU that caused isolation entering or + * exit. + * + * This is necessary because multiple isolation-breaking events may happen + * at once (or one as the result of the other), however isolation exit + * may only happen once to transition from isolated to non-isolated state. + * Therefore, if decrementing this counter results in a value less than 0, + * isolation exit procedure can't be started -- it already happened, or is + * in progress, or isolation is not entered yet. + */ +DEFINE_PER_CPU(atomic_t, isol_counter); + +/* + * Description of the last two tasks that ran isolated on a given CPU. + * This is intended only for messages about isolation breaking. We + * don't want any references to actual task while accessing this from + * CPU that caused isolation breaking -- we know nothing about timing + * and don't want to use locking or RCU. + */ +struct isol_task_desc { + atomic_t curr_index; + atomic_t curr_index_wr; + bool warned[2]; + pid_t pid[2]; + pid_t tgid[2]; + char comm[2][TASK_COMM_LEN]; +}; +static DEFINE_PER_CPU(struct isol_task_desc, isol_task_descs); + +/* + * Counter for isolation exiting procedures (from request to the start of + * cleanup) being attempted at once on a CPU. Normally incrementing of + * this counter is performed from the CPU that caused isolation breaking, + * however decrementing is done from the cleanup procedure, delegated to + * the CPU that is exiting isolation, not from the CPU that caused isolation + * breaking. + * + * If incrementing this counter while starting isolation exit procedure + * results in a value greater than 0, isolation exiting is already in + * progress, and cleanup did not start yet. This means, counter should be + * decremented back, and isolation exit that is already in progress, should + * be allowed to complete. Otherwise, a new isolation exit procedure should + * be started. + */ +DEFINE_PER_CPU(atomic_t, isol_exit_counter); + +/* + * Descriptor for isolation-breaking SMP calls + */ +DEFINE_PER_CPU(call_single_data_t, isol_break_csd); + +cpumask_var_t task_isolation_map; +cpumask_var_t task_isolation_cleanup_map; +static DEFINE_SPINLOCK(task_isolation_cleanup_lock); + +/* We can run on cpus that are isolated from the scheduler and are nohz_full. */ +static int __init task_isolation_init(void) +{ + alloc_bootmem_cpumask_var(&task_isolation_cleanup_map); + if (alloc_cpumask_var(&task_isolation_map, GFP_KERNEL)) + /* + * At this point task isolation should match + * nohz_full. This may change in the future. + */ + cpumask_copy(task_isolation_map, tick_nohz_full_mask); + return 0; +} +core_initcall(task_isolation_init) + +/* Enable stack backtraces of any interrupts of task_isolation cores. */ +static bool task_isolation_debug; +static int __init task_isolation_debug_func(char *str) +{ + task_isolation_debug = true; + return 1; +} +__setup("task_isolation_debug", task_isolation_debug_func); + +/* + * Record name, pid and group pid of the task entering isolation on + * the current CPU. + */ +static void record_curr_isolated_task(void) +{ + int ind; + int cpu = smp_processor_id(); + struct isol_task_desc *desc = &per_cpu(isol_task_descs, cpu); + struct task_struct *task = current; + + /* Finish everything before recording current task */ + smp_mb(); + ind = atomic_inc_return(&desc->curr_index_wr) & 1; + desc->comm[ind][sizeof(task->comm) - 1] = '\0'; + memcpy(desc->comm[ind], task->comm, sizeof(task->comm) - 1); + desc->pid[ind] = task->pid; + desc->tgid[ind] = task->tgid; + desc->warned[ind] = false; + /* Write everything, to be seen by other CPUs */ + smp_mb(); + atomic_inc(&desc->curr_index); + /* Everyone will see the new record from this point */ + smp_mb(); +} + +/* + * Print message prefixed with the description of the current (or + * last) isolated task on a given CPU. Intended for isolation breaking + * messages that include target task for the user's convenience. + * + * Messages produced with this function may have obsolete task + * information if isolated tasks managed to exit, start and enter + * isolation multiple times, or multiple tasks tried to enter + * isolation on the same CPU at once. For those unusual cases it would + * contain a valid description of the cause for isolation breaking and + * target CPU number, just not the correct description of which task + * ended up losing isolation. + */ +int task_isolation_message(int cpu, int level, bool supp, const char *fmt, ...) +{ + struct isol_task_desc *desc; + struct task_struct *task; + va_list args; + char buf_prefix[TASK_COMM_LEN + 20 + 3 * 20]; + char buf[200]; + int curr_cpu, ind_counter, ind_counter_old, ind; + + curr_cpu = get_cpu(); + desc = &per_cpu(isol_task_descs, cpu); + ind_counter = atomic_read(&desc->curr_index); + + if (curr_cpu == cpu) { + /* + * Message is for the current CPU so current + * task_struct should be used instead of cached + * information. + * + * Like in other diagnostic messages, if issued from + * interrupt context, current will be the interrupted + * task. Unlike other diagnostic messages, this is + * always relevant because the message is about + * interrupting a task. + */ + ind = ind_counter & 1; + if (supp && desc->warned[ind]) { + /* + * If supp is true, skip the message if the + * same task was mentioned in the message + * originated on remote CPU, and it did not + * re-enter isolated state since then (warned + * is true). Only local messages following + * remote messages, likely about the same + * isolation breaking event, are skipped to + * avoid duplication. If remote cause is + * immediately followed by a local one before + * isolation is broken, local cause is skipped + * from messages. + */ + put_cpu(); + return 0; + } + task = current; + snprintf(buf_prefix, sizeof(buf_prefix), + "isolation %s/%d/%d (cpu %d)", + task->comm, task->tgid, task->pid, cpu); + put_cpu(); + } else { + /* + * Message is for remote CPU, use cached information. + */ + put_cpu(); + /* + * Make sure, index remained unchanged while data was + * copied. If it changed, data that was copied may be + * inconsistent because two updates in a sequence could + * overwrite the data while it was being read. + */ + do { + /* Make sure we are reading up to date values */ + smp_mb(); + ind = ind_counter & 1; + snprintf(buf_prefix, sizeof(buf_prefix), + "isolation %s/%d/%d (cpu %d)", + desc->comm[ind], desc->tgid[ind], + desc->pid[ind], cpu); + desc->warned[ind] = true; + ind_counter_old = ind_counter; + /* Record the warned flag, then re-read descriptor */ + smp_mb(); + ind_counter = atomic_read(&desc->curr_index); + /* + * If the counter changed, something was updated, so + * repeat everything to get the current data + */ + } while (ind_counter != ind_counter_old); + } + + va_start(args, fmt); + vsnprintf(buf, sizeof(buf), fmt, args); + va_end(args); + + switch (level) { + case LOGLEVEL_EMERG: + pr_emerg("%s: %s", buf_prefix, buf); + break; + case LOGLEVEL_ALERT: + pr_alert("%s: %s", buf_prefix, buf); + break; + case LOGLEVEL_CRIT: + pr_crit("%s: %s", buf_prefix, buf); + break; + case LOGLEVEL_ERR: + pr_err("%s: %s", buf_prefix, buf); + break; + case LOGLEVEL_WARNING: + pr_warn("%s: %s", buf_prefix, buf); + break; + case LOGLEVEL_NOTICE: + pr_notice("%s: %s", buf_prefix, buf); + break; + case LOGLEVEL_INFO: + pr_info("%s: %s", buf_prefix, buf); + break; + case LOGLEVEL_DEBUG: + pr_debug("%s: %s", buf_prefix, buf); + break; + default: + /* No message without a valid level */ + return 0; + } + return 1; +} + +/* + * Dump stack if need be. This can be helpful even from the final exit + * to usermode code since stack traces sometimes carry information about + * what put you into the kernel, e.g. an interrupt number encoded in + * the initial entry stack frame that is still visible at exit time. + */ +static void debug_dump_stack(void) +{ + if (task_isolation_debug) + dump_stack(); +} + +/* + * Set the flags word but don't try to actually start task isolation yet. + * We will start it when entering user space in task_isolation_start(). + */ +int task_isolation_request(unsigned int flags) +{ + struct task_struct *task = current; + + /* + * The task isolation flags should always be cleared just by + * virtue of having entered the kernel. + */ + WARN_ON_ONCE(test_tsk_thread_flag(task, TIF_TASK_ISOLATION)); + WARN_ON_ONCE(task->task_isolation_flags != 0); + WARN_ON_ONCE(task->task_isolation_state != STATE_NORMAL); + + task->task_isolation_flags = flags; + if (!(task->task_isolation_flags & PR_TASK_ISOLATION_ENABLE)) + return 0; + + /* We are trying to enable task isolation. */ + set_tsk_thread_flag(task, TIF_TASK_ISOLATION); + + /* + * Shut down the vmstat worker so we're not interrupted later. + * We have to try to do this here (with interrupts enabled) since + * we are canceling delayed work and will call flush_work() + * (which enables interrupts) and possibly schedule(). + */ + quiet_vmstat_sync(); + + /* We return 0 here but we may change that in task_isolation_start(). */ + return 0; +} + +/* + * Perform actions that should be done immediately on exit from isolation. + */ +static void fast_task_isolation_cpu_cleanup(void *info) +{ + atomic_dec(&per_cpu(isol_exit_counter, smp_processor_id())); + /* At this point breaking isolation from other CPUs is possible again */ + + /* + * This task is no longer isolated (and if by any chance this + * is the wrong task, it's already not isolated) + */ + current->task_isolation_flags = 0; + clear_tsk_thread_flag(current, TIF_TASK_ISOLATION); + + /* Run the rest of cleanup later */ + set_tsk_thread_flag(current, TIF_NOTIFY_RESUME); + + /* Copy flags with task isolation disabled */ + this_cpu_write(tsk_thread_flags_cache, + READ_ONCE(task_thread_info(current)->flags)); +} + +/* Disable task isolation for the specified task. */ +static void stop_isolation(struct task_struct *p) +{ + int cpu, this_cpu; + unsigned long flags; + + this_cpu = get_cpu(); + cpu = task_cpu(p); + if (atomic_inc_return(&per_cpu(isol_exit_counter, cpu)) > 1) { + /* Already exiting isolation */ + atomic_dec(&per_cpu(isol_exit_counter, cpu)); + put_cpu(); + return; + } + + if (p == current) { + p->task_isolation_state = STATE_NORMAL; + fast_task_isolation_cpu_cleanup(NULL); + task_isolation_cpu_cleanup(); + if (atomic_dec_return(&per_cpu(isol_counter, cpu)) < 0) { + /* Is not isolated already */ + atomic_inc(&per_cpu(isol_counter, cpu)); + } + put_cpu(); + } else { + if (atomic_dec_return(&per_cpu(isol_counter, cpu)) < 0) { + /* Is not isolated already */ + atomic_inc(&per_cpu(isol_counter, cpu)); + atomic_dec(&per_cpu(isol_exit_counter, cpu)); + put_cpu(); + return; + } + /* + * Schedule "slow" cleanup. This relies on + * TIF_NOTIFY_RESUME being set + */ + spin_lock_irqsave(&task_isolation_cleanup_lock, flags); + cpumask_set_cpu(cpu, task_isolation_cleanup_map); + spin_unlock_irqrestore(&task_isolation_cleanup_lock, flags); + /* + * Setting flags is delegated to the CPU where + * isolated task is running + * isol_exit_counter will be decremented from there as well. + */ + per_cpu(isol_break_csd, cpu).func = + fast_task_isolation_cpu_cleanup; + per_cpu(isol_break_csd, cpu).info = NULL; + per_cpu(isol_break_csd, cpu).flags = 0; + smp_call_function_single_async(cpu, + &per_cpu(isol_break_csd, cpu)); + put_cpu(); + } +} + +/* + * This code runs with interrupts disabled just before the return to + * userspace, after a prctl() has requested enabling task isolation. + * We take whatever steps are needed to avoid being interrupted later: + * drain the lru pages, stop the scheduler tick, etc. More + * functionality may be added here later to avoid other types of + * interrupts from other kernel subsystems. + * + * If we can't enable task isolation, we update the syscall return + * value with an appropriate error. + */ +void task_isolation_start(void) +{ + int error; + + /* + * We should only be called in STATE_NORMAL (isolation disabled), + * on our way out of the kernel from the prctl() that turned it on. + * If we are exiting from the kernel in another state, it means we + * made it back into the kernel without disabling task isolation, + * and we should investigate how (and in any case disable task + * isolation at this point). We are clearly not on the path back + * from the prctl() so we don't touch the syscall return value. + */ + if (WARN_ON_ONCE(current->task_isolation_state != STATE_NORMAL)) { + /* Increment counter, this will allow isolation breaking */ + if (atomic_inc_return(&per_cpu(isol_counter, + smp_processor_id())) > 1) { + atomic_dec(&per_cpu(isol_counter, smp_processor_id())); + } + atomic_inc(&per_cpu(isol_counter, smp_processor_id())); + stop_isolation(current); + return; + } + + /* + * Must be affinitized to a single core with task isolation possible. + * In principle this could be remotely modified between the prctl() + * and the return to userspace, so we have to check it here. + */ + if (current->nr_cpus_allowed != 1 || + !is_isolation_cpu(smp_processor_id())) { + error = -EINVAL; + goto error; + } + + /* If the vmstat delayed work is not canceled, we have to try again. */ + if (!vmstat_idle()) { + error = -EAGAIN; + goto error; + } + + /* Try to stop the dynamic tick. */ + error = try_stop_full_tick(); + if (error) + goto error; + + /* Drain the pagevecs to avoid unnecessary IPI flushes later. */ + lru_add_drain(); + + /* Increment counter, this will allow isolation breaking */ + if (atomic_inc_return(&per_cpu(isol_counter, + smp_processor_id())) > 1) { + atomic_dec(&per_cpu(isol_counter, smp_processor_id())); + } + + /* Record isolated task IDs and name */ + record_curr_isolated_task(); + + /* Copy flags with task isolation enabled */ + this_cpu_write(tsk_thread_flags_cache, + READ_ONCE(task_thread_info(current)->flags)); + + current->task_isolation_state = STATE_ISOLATED; + return; + +error: + /* Increment counter, this will allow isolation breaking */ + if (atomic_inc_return(&per_cpu(isol_counter, + smp_processor_id())) > 1) { + atomic_dec(&per_cpu(isol_counter, smp_processor_id())); + } + stop_isolation(current); + syscall_set_return_value(current, current_pt_regs(), error, 0); +} + +/* Stop task isolation on the remote task and send it a signal. */ +static void send_isolation_signal(struct task_struct *task) +{ + int flags = task->task_isolation_flags; + kernel_siginfo_t info = { + .si_signo = PR_TASK_ISOLATION_GET_SIG(flags) ?: SIGKILL, + }; + + stop_isolation(task); + send_sig_info(info.si_signo, &info, task); +} + +/* Only a few syscalls are valid once we are in task isolation mode. */ +static bool is_acceptable_syscall(int syscall) +{ + /* No need to incur an isolation signal if we are just exiting. */ + if (syscall == __NR_exit || syscall == __NR_exit_group) + return true; + + /* Check to see if it's the prctl for isolation. */ + if (syscall == __NR_prctl) { + unsigned long arg[SYSCALL_MAX_ARGS]; + + syscall_get_arguments(current, current_pt_regs(), arg); + if (arg[0] == PR_TASK_ISOLATION) + return true; + } + + return false; +} + +/* + * This routine is called from syscall entry, prevents most syscalls + * from executing, and if needed raises a signal to notify the process. + * + * Note that we have to stop isolation before we even print a message + * here, since otherwise we might end up reporting an interrupt due to + * kicking the printk handling code, rather than reporting the true + * cause of interrupt here. + * + * The message is not suppressed by previous remotely triggered + * messages. + */ +int task_isolation_syscall(int syscall) +{ + struct task_struct *task = current; + + if (is_acceptable_syscall(syscall)) { + stop_isolation(task); + return 0; + } + + send_isolation_signal(task); + + pr_task_isol_warn(smp_processor_id(), + "task_isolation lost due to syscall %d\n", + syscall); + debug_dump_stack(); + + syscall_set_return_value(task, current_pt_regs(), -ERESTARTNOINTR, -1); + return -1; +} + +/* + * This routine is called from any exception or irq that doesn't + * otherwise trigger a signal to the user process (e.g. page fault). + * + * Messages will be suppressed if there is already a reported remote + * cause for isolation breaking, so we don't generate multiple + * confusingly similar messages about the same event. + */ +void _task_isolation_interrupt(const char *fmt, ...) +{ + struct task_struct *task = current; + va_list args; + char buf[100]; + + /* RCU should have been enabled prior to this point. */ + RCU_LOCKDEP_WARN(!rcu_is_watching(), "kernel entry without RCU"); + + /* Are we exiting isolation already? */ + if (atomic_read(&per_cpu(isol_exit_counter, smp_processor_id())) != 0) { + task->task_isolation_state = STATE_NORMAL; + return; + } + /* + * Avoid reporting interrupts that happen after we have prctl'ed + * to enable isolation, but before we have returned to userspace. + */ + if (task->task_isolation_state == STATE_NORMAL) + return; + + va_start(args, fmt); + vsnprintf(buf, sizeof(buf), fmt, args); + va_end(args); + + /* Handle NMIs minimally, since we can't send a signal. */ + if (in_nmi()) { + pr_task_isol_err(smp_processor_id(), + "isolation: in NMI; not delivering signal\n"); + } else { + send_isolation_signal(task); + } + + if (pr_task_isol_warn_supp(smp_processor_id(), + "task_isolation lost due to %s\n", buf)) + debug_dump_stack(); +} + +/* + * Called before we wake up a task that has a signal to process. + * Needs to be done to handle interrupts that trigger signals, which + * we don't catch with task_isolation_interrupt() hooks. + * + * This message is also suppressed if there was already a remotely + * caused message about the same isolation breaking event. + */ +void _task_isolation_signal(struct task_struct *task) +{ + struct isol_task_desc *desc; + int ind, cpu; + bool do_warn = (task->task_isolation_state == STATE_ISOLATED); + + cpu = task_cpu(task); + desc = &per_cpu(isol_task_descs, cpu); + ind = atomic_read(&desc->curr_index) & 1; + if (desc->warned[ind]) + do_warn = false; + + stop_isolation(task); + + if (do_warn) { + pr_warn("isolation: %s/%d/%d (cpu %d): task_isolation lost due to signal\n", + task->comm, task->tgid, task->pid, cpu); + debug_dump_stack(); + } +} + +/* + * Generate a stack backtrace if we are going to interrupt another task + * isolation process. + */ +void task_isolation_remote(int cpu, const char *fmt, ...) +{ + struct task_struct *curr_task; + va_list args; + char buf[200]; + + if (!is_isolation_cpu(cpu) || !task_isolation_on_cpu(cpu)) + return; + + curr_task = current; + + va_start(args, fmt); + vsnprintf(buf, sizeof(buf), fmt, args); + va_end(args); + if (pr_task_isol_warn(cpu, + "task_isolation lost due to %s by %s/%d/%d on cpu %d\n", + buf, + curr_task->comm, curr_task->tgid, + curr_task->pid, smp_processor_id())) + debug_dump_stack(); +} + +/* + * Generate a stack backtrace if any of the cpus in "mask" are running + * task isolation processes. + */ +void task_isolation_remote_cpumask(const struct cpumask *mask, + const char *fmt, ...) +{ + struct task_struct *curr_task; + cpumask_var_t warn_mask; + va_list args; + char buf[200]; + int cpu, first_cpu; + + if (task_isolation_map == NULL || + !zalloc_cpumask_var(&warn_mask, GFP_KERNEL)) + return; + + first_cpu = -1; + for_each_cpu_and(cpu, mask, task_isolation_map) { + if (task_isolation_on_cpu(cpu)) { + if (first_cpu < 0) + first_cpu = cpu; + else + cpumask_set_cpu(cpu, warn_mask); + } + } + + if (first_cpu < 0) + goto done; + + curr_task = current; + + va_start(args, fmt); + vsnprintf(buf, sizeof(buf), fmt, args); + va_end(args); + + if (cpumask_weight(warn_mask) == 0) + pr_task_isol_warn(first_cpu, + "task_isolation lost due to %s by %s/%d/%d on cpu %d\n", + buf, curr_task->comm, curr_task->tgid, + curr_task->pid, smp_processor_id()); + else + pr_task_isol_warn(first_cpu, + " and cpus %*pbl: task_isolation lost due to %s by %s/%d/%d on cpu %d\n", + cpumask_pr_args(warn_mask), + buf, curr_task->comm, curr_task->tgid, + curr_task->pid, smp_processor_id()); + debug_dump_stack(); + +done: + free_cpumask_var(warn_mask); +} + +/* + * Check if given CPU is running isolated task. + */ +int task_isolation_on_cpu(int cpu) +{ + return test_bit(TIF_TASK_ISOLATION, + &per_cpu(tsk_thread_flags_cache, cpu)); +} + +/* + * Set CPUs currently running isolated tasks in CPU mask. + */ +void task_isolation_cpumask(struct cpumask *mask) +{ + int cpu; + + if (task_isolation_map == NULL) + return; + + for_each_cpu(cpu, task_isolation_map) + if (task_isolation_on_cpu(cpu)) + cpumask_set_cpu(cpu, mask); +} + +/* + * Clear CPUs currently running isolated tasks in CPU mask. + */ +void task_isolation_clear_cpumask(struct cpumask *mask) +{ + int cpu; + + if (task_isolation_map == NULL) + return; + + for_each_cpu(cpu, task_isolation_map) + if (task_isolation_on_cpu(cpu)) + cpumask_clear_cpu(cpu, mask); +} + +/* + * Cleanup procedure. The call to this procedure may be delayed. + */ +void task_isolation_cpu_cleanup(void) +{ + kick_hrtimer(); +} + +/* + * Check if cleanup is scheduled on the current CPU, and if so, run it. + * Intended to be called from notify_resume() or another such callback + * on the target CPU. + */ +void task_isolation_check_run_cleanup(void) +{ + int cpu; + unsigned long flags; + + spin_lock_irqsave(&task_isolation_cleanup_lock, flags); + + cpu = smp_processor_id(); + + if (cpumask_test_cpu(cpu, task_isolation_cleanup_map)) { + cpumask_clear_cpu(cpu, task_isolation_cleanup_map); + spin_unlock_irqrestore(&task_isolation_cleanup_lock, flags); + task_isolation_cpu_cleanup(); + } else + spin_unlock_irqrestore(&task_isolation_cleanup_lock, flags); +} diff --git a/kernel/signal.c b/kernel/signal.c index 5b2396350dd1..1df57e38c361 100644 --- a/kernel/signal.c +++ b/kernel/signal.c @@ -46,6 +46,7 @@ #include #include #include +#include #define CREATE_TRACE_POINTS #include @@ -758,6 +759,7 @@ static int dequeue_synchronous_signal(kernel_siginfo_t *info) */ void signal_wake_up_state(struct task_struct *t, unsigned int state) { + task_isolation_signal(t); set_tsk_thread_flag(t, TIF_SIGPENDING); /* * TASK_WAKEKILL also means wake it up in the stopped/traced/killable diff --git a/kernel/sys.c b/kernel/sys.c index f9bc5c303e3f..0a4059a8c4f9 100644 --- a/kernel/sys.c +++ b/kernel/sys.c @@ -42,6 +42,7 @@ #include #include #include +#include #include #include @@ -2513,6 +2514,11 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3, error = (current->flags & PR_IO_FLUSHER) == PR_IO_FLUSHER; break; + case PR_TASK_ISOLATION: + if (arg3 || arg4 || arg5) + return -EINVAL; + error = task_isolation_request(arg2); + break; default: error = -EINVAL; break; diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c index 3a609e7344f3..5bb98f39bde6 100644 --- a/kernel/time/hrtimer.c +++ b/kernel/time/hrtimer.c @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include @@ -721,6 +722,19 @@ static void retrigger_next_event(void *arg) raw_spin_unlock(&base->lock); } +#ifdef CONFIG_TASK_ISOLATION +void kick_hrtimer(void) +{ + unsigned long flags; + + preempt_disable(); + local_irq_save(flags); + retrigger_next_event(NULL); + local_irq_restore(flags); + preempt_enable(); +} +#endif + /* * Switch to high resolution mode */ @@ -868,8 +882,21 @@ static void hrtimer_reprogram(struct hrtimer *timer, bool reprogram) void clock_was_set(void) { #ifdef CONFIG_HIGH_RES_TIMERS +#ifdef CONFIG_TASK_ISOLATION + struct cpumask mask; + + cpumask_clear(&mask); + task_isolation_cpumask(&mask); + cpumask_complement(&mask, &mask); + /* + * Retrigger the CPU local events everywhere except CPUs + * running isolated tasks. + */ + on_each_cpu_mask(&mask, retrigger_next_event, NULL, 1); +#else /* Retrigger the CPU local events everywhere */ on_each_cpu(retrigger_next_event, NULL, 1); +#endif #endif timerfd_clock_was_set(); } diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c index a792d21cac64..1d4dec9d3ee7 100644 --- a/kernel/time/tick-sched.c +++ b/kernel/time/tick-sched.c @@ -882,6 +882,24 @@ static void tick_nohz_full_update_tick(struct tick_sched *ts) #endif } +#ifdef CONFIG_TASK_ISOLATION +int try_stop_full_tick(void) +{ + int cpu = smp_processor_id(); + struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched); + + /* For an unstable clock, we should return a permanent error code. */ + if (atomic_read(&tick_dep_mask) & TICK_DEP_MASK_CLOCK_UNSTABLE) + return -EINVAL; + + if (!can_stop_full_tick(cpu, ts)) + return -EAGAIN; + + tick_nohz_stop_sched_tick(ts, cpu); + return 0; +} +#endif + static bool can_stop_idle_tick(int cpu, struct tick_sched *ts) { /* -- 2.20.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx0a-0016f401.pphosted.com ([67.231.148.174]:50270 "EHLO mx0b-0016f401.pphosted.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726116AbgCHDr7 (ORCPT ); Sat, 7 Mar 2020 22:47:59 -0500 From: Alex Belits Subject: [PATCH v2 03/12] task_isolation: userspace hard isolation from kernel Date: Sun, 8 Mar 2020 03:47:08 +0000 Message-ID: <105f17f25e90a9a58299a7ed644bdd0f36434c87.camel@marvell.com> References: <4473787e1b6bc3cc226067e8d122092a678b63de.camel@marvell.com> In-Reply-To: Content-Language: en-US Content-Type: text/plain; charset="utf-8" Content-ID: <86098B5433923643954377077B047068@namprd18.prod.outlook.com> Content-Transfer-Encoding: base64 MIME-Version: 1.0 Sender: linux-arch-owner@vger.kernel.org List-ID: To: "frederic@kernel.org" , "rostedt@goodmis.org" Cc: "mingo@kernel.org" , "peterz@infradead.org" , "linux-kernel@vger.kernel.org" , Prasun Kapoor , "tglx@linutronix.de" , "linux-api@vger.kernel.org" , "catalin.marinas@arm.com" , "linux-arm-kernel@lists.infradead.org" , "netdev@vger.kernel.org" , "davem@davemloft.net" , "linux-arch@vger.kernel.org" , "will@kernel.org" Message-ID: <20200308034708.fPmkU5erzjvocGvo6PqLQd4jtDQ-XYcOVH_UlAU9tpg@z> VGhlIGV4aXN0aW5nIG5vaHpfZnVsbCBtb2RlIGlzIGRlc2lnbmVkIGFzIGEgInNvZnQiIGlzb2xh dGlvbiBtb2RlDQp0aGF0IG1ha2VzIHRyYWRlb2ZmcyB0byBtaW5pbWl6ZSB1c2Vyc3BhY2UgaW50 ZXJydXB0aW9ucyB3aGlsZQ0Kc3RpbGwgYXR0ZW1wdGluZyB0byBhdm9pZCBvdmVyaGVhZHMgaW4g dGhlIGtlcm5lbCBlbnRyeS9leGl0IHBhdGgsDQp0byBwcm92aWRlIDEwMCUga2VybmVsIHNlbWFu dGljcywgZXRjLg0KDQpIb3dldmVyLCBzb21lIGFwcGxpY2F0aW9ucyByZXF1aXJlIGEgImhhcmQi IGNvbW1pdG1lbnQgZnJvbSB0aGUNCmtlcm5lbCB0byBhdm9pZCBpbnRlcnJ1cHRpb25zLCBpbiBw YXJ0aWN1bGFyIHVzZXJzcGFjZSBkZXZpY2UgZHJpdmVyDQpzdHlsZSBhcHBsaWNhdGlvbnMsIHN1 Y2ggYXMgaGlnaC1zcGVlZCBuZXR3b3JraW5nIGNvZGUuDQoNClRoaXMgY2hhbmdlIGludHJvZHVj ZXMgYSBmcmFtZXdvcmsgdG8gYWxsb3cgYXBwbGljYXRpb25zDQp0byBlbGVjdCB0byBoYXZlIHRo ZSAiaGFyZCIgc2VtYW50aWNzIGFzIG5lZWRlZCwgc3BlY2lmeWluZw0KcHJjdGwoUFJfVEFTS19J U09MQVRJT04sIFBSX1RBU0tfSVNPTEFUSU9OX0VOQUJMRSkgdG8gZG8gc28uDQoNClRoZSBrZXJu ZWwgbXVzdCBiZSBidWlsdCB3aXRoIHRoZSBuZXcgVEFTS19JU09MQVRJT04gS2NvbmZpZyBmbGFn DQp0byBlbmFibGUgdGhpcyBtb2RlLCBhbmQgdGhlIGtlcm5lbCBib290ZWQgd2l0aCBhbiBhcHBy b3ByaWF0ZQ0KImlzb2xjcHVzPW5vaHosZG9tYWluLENQVUxJU1QiIGJvb3QgYXJndW1lbnQgdG8g ZW5hYmxlDQpub2h6X2Z1bGwgYW5kIGlzb2xjcHVzLiBUaGUgInRhc2tfaXNvbGF0aW9uIiBzdGF0 ZSBpcyB0aGVuIGluZGljYXRlZA0KYnkgc2V0dGluZyBhIG5ldyB0YXNrIHN0cnVjdCBmaWVsZCwg dGFza19pc29sYXRpb25fZmxhZywgdG8gdGhlDQp2YWx1ZSBwYXNzZWQgYnkgcHJjdGwoKSwgYW5k IGFsc28gc2V0dGluZyBhIFRJRl9UQVNLX0lTT0xBVElPTg0KYml0IGluIHRoZSB0aHJlYWRfaW5m byBmbGFncy4gV2hlbiB0aGUga2VybmVsIGlzIHJldHVybmluZyB0bw0KdXNlcnNwYWNlIGZyb20g dGhlIHByY3RsKCkgY2FsbCBhbmQgc2VlcyBUSUZfVEFTS19JU09MQVRJT04gc2V0LA0KaXQgY2Fs bHMgdGhlIG5ldyB0YXNrX2lzb2xhdGlvbl9zdGFydCgpIHJvdXRpbmUgdG8gYXJyYW5nZSBmb3IN CnRoZSB0YXNrIHRvIGF2b2lkIGJlaW5nIGludGVycnVwdGVkIGluIHRoZSBmdXR1cmUuDQoNCldp dGggaW50ZXJydXB0cyBkaXNhYmxlZCwgdGFza19pc29sYXRpb25fc3RhcnQoKSBlbnN1cmVzIHRo YXQga2VybmVsDQpzdWJzeXN0ZW1zIHRoYXQgbWlnaHQgY2F1c2UgYSBmdXR1cmUgaW50ZXJydXB0 IGFyZSBxdWllc2NlZC4gSWYgaXQNCmRvZXNuJ3Qgc3VjY2VlZCwgaXQgYWRqdXN0cyB0aGUgc3lz Y2FsbCByZXR1cm4gdmFsdWUgdG8gaW5kaWNhdGUgdGhhdA0KZmFjdCwgYW5kIHVzZXJzcGFjZSBj YW4gcmV0cnkgYXMgZGVzaXJlZC4gSW4gYWRkaXRpb24gdG8gc3RvcHBpbmcNCnRoZSBzY2hlZHVs ZXIgdGljaywgdGhlIGNvZGUgdGFrZXMgYW55IGFjdGlvbnMgdGhhdCBtaWdodCBhdm9pZA0KYSBm dXR1cmUgaW50ZXJydXB0IHRvIHRoZSBjb3JlLCBzdWNoIGFzIGEgd29ya2VyIHRocmVhZCBiZWlu Zw0Kc2NoZWR1bGVkIHRoYXQgY291bGQgYmUgcXVpZXNjZWQgbm93IChlLmcuIHRoZSB2bXN0YXQg d29ya2VyKQ0Kb3IgYSBmdXR1cmUgSVBJIHRvIHRoZSBjb3JlIHRvIGNsZWFuIHVwIHNvbWUgc3Rh dGUgdGhhdCBjb3VsZCBiZQ0KY2xlYW5lZCB1cCBub3cgKGUuZy4gdGhlIG1tIGxydSBwZXItY3B1 IGNhY2hlKS4NCg0KT25jZSB0aGUgdGFzayBoYXMgcmV0dXJuZWQgdG8gdXNlcnNwYWNlIGFmdGVy IGlzc3VpbmcgdGhlIHByY3RsKCksDQppZiBpdCBlbnRlcnMgdGhlIGtlcm5lbCBhZ2FpbiB2aWEg c3lzdGVtIGNhbGwsIHBhZ2UgZmF1bHQsIG9yIGFueQ0Kb3RoZXIgZXhjZXB0aW9uIG9yIGlycSwg dGhlIGtlcm5lbCB3aWxsIGtpbGwgaXQgd2l0aCBTSUdLSUxMLg0KSW4gYWRkaXRpb24gdG8gc2Vu ZGluZyBhIHNpZ25hbCwgdGhlIGNvZGUgc3VwcG9ydHMgYSBrZXJuZWwNCmNvbW1hbmQtbGluZSAi dGFza19pc29sYXRpb25fZGVidWciIGZsYWcgd2hpY2ggY2F1c2VzIGEgc3RhY2sNCmJhY2t0cmFj ZSB0byBiZSBnZW5lcmF0ZWQgd2hlbmV2ZXIgYSB0YXNrIGxvc2VzIGlzb2xhdGlvbi4NCg0KVG8g YWxsb3cgdGhlIHN0YXRlIHRvIGJlIGVudGVyZWQgYW5kIGV4aXRlZCwgdGhlIHN5c2NhbGwgY2hl Y2tpbmcNCnRlc3QgaWdub3JlcyB0aGUgcHJjdGwoUFJfVEFTS19JU09MQVRJT04pIHN5c2NhbGwg c28gdGhhdCB3ZSBjYW4NCmNsZWFyIHRoZSBiaXQgYWdhaW4gbGF0ZXIsIGFuZCBpZ25vcmVzIGV4 aXQvZXhpdF9ncm91cCB0byBhbGxvdw0KZXhpdGluZyB0aGUgdGFzayB3aXRob3V0IGEgcG9pbnRs ZXNzIHNpZ25hbCBiZWluZyBkZWxpdmVyZWQuDQoNClRoZSBwcmN0bCgpIEFQSSBhbGxvd3MgZm9y IHNwZWNpZnlpbmcgYSBzaWduYWwgbnVtYmVyIHRvIHVzZSBpbnN0ZWFkDQpvZiB0aGUgZGVmYXVs dCBTSUdLSUxMLCB0byBhbGxvdyBmb3IgY2F0Y2hpbmcgdGhlIG5vdGlmaWNhdGlvbg0Kc2lnbmFs OyBmb3IgZXhhbXBsZSwgaW4gYSBwcm9kdWN0aW9uIGVudmlyb25tZW50LCBpdCBtaWdodCBiZQ0K aGVscGZ1bCB0byBsb2cgaW5mb3JtYXRpb24gdG8gdGhlIGFwcGxpY2F0aW9uIGxvZ2dpbmcgbWVj aGFuaXNtDQpiZWZvcmUgZXhpdGluZy4gT3IsIHRoZSBzaWduYWwgaGFuZGxlciBtaWdodCBjaG9v c2UgdG8gcmVzZXQgdGhlDQpwcm9ncmFtIGNvdW50ZXIgYmFjayB0byB0aGUgY29kZSBzZWdtZW50 IGludGVuZGVkIHRvIGJlIHJ1biBpc29sYXRlZA0KdmlhIHByY3RsKCkgdG8gY29udGludWUgZXhl Y3V0aW9uLg0KDQpJbiBhIG51bWJlciBvZiBjYXNlcyB3ZSBjYW4gdGVsbCBvbiBhIHJlbW90ZSBj cHUgdGhhdCB3ZSBhcmUNCmdvaW5nIHRvIGJlIGludGVycnVwdGluZyB0aGUgY3B1LCBlLmcuIHZp YSBhbiBJUEkgb3IgYSBUTEIgZmx1c2guDQpJbiB0aGF0IGNhc2Ugd2UgZ2VuZXJhdGUgdGhlIGRp YWdub3N0aWMgKGFuZCBvcHRpb25hbCBzdGFjayBkdW1wKQ0Kb24gdGhlIHJlbW90ZSBjb3JlIHRv IGJlIGFibGUgdG8gZGVsaXZlciBiZXR0ZXIgZGlhZ25vc3RpY3MuDQpJZiB0aGUgaW50ZXJydXB0 IGlzIG5vdCBzb21ldGhpbmcgY2F1Z2h0IGJ5IExpbnV4IChlLmcuIGENCmh5cGVydmlzb3IgaW50 ZXJydXB0KSB3ZSBjYW4gYWxzbyByZXF1ZXN0IGEgcmVzY2hlZHVsZSBJUEkgdG8NCmJlIHNlbnQg dG8gdGhlIHJlbW90ZSBjb3JlIHNvIGl0IGNhbiBiZSBzdXJlIHRvIGdlbmVyYXRlIGENCnNpZ25h bCB0byBub3RpZnkgdGhlIHByb2Nlc3MuDQoNClNlcGFyYXRlIHBhdGNoZXMgdGhhdCBmb2xsb3cg cHJvdmlkZSB0aGVzZSBjaGFuZ2VzIGZvciB4ODYsIGFybSwNCmFuZCBhcm02NC4NCg0KU2lnbmVk LW9mZi1ieTogQWxleCBCZWxpdHMgPGFiZWxpdHNAbWFydmVsbC5jb20+DQotLS0NCiAuLi4vYWRt aW4tZ3VpZGUva2VybmVsLXBhcmFtZXRlcnMudHh0ICAgICAgICAgfCAgIDYgKw0KIGluY2x1ZGUv bGludXgvaHJ0aW1lci5oICAgICAgICAgICAgICAgICAgICAgICB8ICAgNCArDQogaW5jbHVkZS9s aW51eC9pc29sYXRpb24uaCAgICAgICAgICAgICAgICAgICAgIHwgMjI5ICsrKysrKw0KIGluY2x1 ZGUvbGludXgvc2NoZWQuaCAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgNCArDQogaW5jbHVk ZS9saW51eC90aWNrLmggICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAzICsNCiBpbmNsdWRl L3VhcGkvbGludXgvcHJjdGwuaCAgICAgICAgICAgICAgICAgICAgfCAgIDYgKw0KIGluaXQvS2Nv bmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAyOCArDQoga2VybmVsL01h a2VmaWxlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAyICsNCiBrZXJuZWwvY29u dGV4dF90cmFja2luZy5jICAgICAgICAgICAgICAgICAgICAgfCAgIDIgKw0KIGtlcm5lbC9pc29s YXRpb24uYyAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IDc3NCArKysrKysrKysrKysrKysr KysNCiBrZXJuZWwvc2lnbmFsLmMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDIg Kw0KIGtlcm5lbC9zeXMuYyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgNiAr DQoga2VybmVsL3RpbWUvaHJ0aW1lci5jICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDI3ICsN CiBrZXJuZWwvdGltZS90aWNrLXNjaGVkLmMgICAgICAgICAgICAgICAgICAgICAgfCAgMTggKw0K IDE0IGZpbGVzIGNoYW5nZWQsIDExMTEgaW5zZXJ0aW9ucygrKQ0KIGNyZWF0ZSBtb2RlIDEwMDY0 NCBpbmNsdWRlL2xpbnV4L2lzb2xhdGlvbi5oDQogY3JlYXRlIG1vZGUgMTAwNjQ0IGtlcm5lbC9p c29sYXRpb24uYw0KDQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9rZXJu ZWwtcGFyYW1ldGVycy50eHQgYi9Eb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL2tlcm5lbC1wYXJh bWV0ZXJzLnR4dA0KaW5kZXggYzA3ODE1ZDIzMGJjLi5lNGEyZDZlMzc2NDUgMTAwNjQ0DQotLS0g YS9Eb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL2tlcm5lbC1wYXJhbWV0ZXJzLnR4dA0KKysrIGIv RG9jdW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9rZXJuZWwtcGFyYW1ldGVycy50eHQNCkBAIC00ODA4 LDYgKzQ4MDgsMTIgQEANCiAJCQluZXV0cmFsaXplIGFueSBlZmZlY3Qgb2YgL3Byb2Mvc3lzL2tl cm5lbC9zeXNycS4NCiAJCQlVc2VmdWwgZm9yIGRlYnVnZ2luZy4NCiANCisJdGFza19pc29sYXRp b25fZGVidWcJW0tOTF0NCisJCQlJbiBrZXJuZWxzIGJ1aWx0IHdpdGggQ09ORklHX1RBU0tfSVNP TEFUSU9OLCB0aGlzDQorCQkJc2V0dGluZyB3aWxsIGdlbmVyYXRlIGNvbnNvbGUgYmFja3RyYWNl cyB0bw0KKwkJCWFjY29tcGFueSB0aGUgZGlhZ25vc3RpY3MgZ2VuZXJhdGVkIGFib3V0DQorCQkJ aW50ZXJydXB0aW5nIHRhc2tzIHJ1bm5pbmcgd2l0aCB0YXNrIGlzb2xhdGlvbi4NCisNCiAJdGNw bWhhc2hfZW50cmllcz0gW0tOTCxORVRdDQogCQkJU2V0IHRoZSBudW1iZXIgb2YgdGNwX21ldHJp Y3NfaGFzaCBzbG90cy4NCiAJCQlEZWZhdWx0IHZhbHVlIGlzIDgxOTIgb3IgMTYzODQgZGVwZW5k aW5nIG9uIHRvdGFsDQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9ocnRpbWVyLmggYi9pbmNs dWRlL2xpbnV4L2hydGltZXIuaA0KaW5kZXggMTVjOGFjMzEzNjc4Li5lODEyNTJlYjRmOTIgMTAw NjQ0DQotLS0gYS9pbmNsdWRlL2xpbnV4L2hydGltZXIuaA0KKysrIGIvaW5jbHVkZS9saW51eC9o cnRpbWVyLmgNCkBAIC01MjgsNiArNTI4LDEwIEBAIGV4dGVybiB2b2lkIF9faW5pdCBocnRpbWVy c19pbml0KHZvaWQpOw0KIC8qIFNob3cgcGVuZGluZyB0aW1lcnM6ICovDQogZXh0ZXJuIHZvaWQg c3lzcnFfdGltZXJfbGlzdF9zaG93KHZvaWQpOw0KIA0KKyNpZmRlZiBDT05GSUdfVEFTS19JU09M QVRJT04NCitleHRlcm4gdm9pZCBraWNrX2hydGltZXIodm9pZCk7DQorI2VuZGlmDQorDQogaW50 IGhydGltZXJzX3ByZXBhcmVfY3B1KHVuc2lnbmVkIGludCBjcHUpOw0KICNpZmRlZiBDT05GSUdf SE9UUExVR19DUFUNCiBpbnQgaHJ0aW1lcnNfZGVhZF9jcHUodW5zaWduZWQgaW50IGNwdSk7DQpk aWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9pc29sYXRpb24uaCBiL2luY2x1ZGUvbGludXgvaXNv bGF0aW9uLmgNCm5ldyBmaWxlIG1vZGUgMTAwNjQ0DQppbmRleCAwMDAwMDAwMDAwMDAuLjZiZDcx YzY3ZjEwZg0KLS0tIC9kZXYvbnVsbA0KKysrIGIvaW5jbHVkZS9saW51eC9pc29sYXRpb24uaA0K QEAgLTAsMCArMSwyMjkgQEANCisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1v bmx5ICovDQorLyoNCisgKiBUYXNrIGlzb2xhdGlvbiBzdXBwb3J0DQorICoNCisgKiBBdXRob3Jz Og0KKyAqICAgQ2hyaXMgTWV0Y2FsZiA8Y21ldGNhbGZAbWVsbGFub3guY29tPg0KKyAqICAgQWxl eCBCZWxpdHMgPGFiZWxpdHNAbWFydmVsbC5jb20+DQorICogICBZdXJpIE5vcm92IDx5bm9yb3ZA bWFydmVsbC5jb20+DQorICovDQorI2lmbmRlZiBfTElOVVhfSVNPTEFUSU9OX0gNCisjZGVmaW5l IF9MSU5VWF9JU09MQVRJT05fSA0KKw0KKyNpbmNsdWRlIDxzdGRhcmcuaD4NCisjaW5jbHVkZSA8 bGludXgvZXJybm8uaD4NCisjaW5jbHVkZSA8bGludXgvY3B1bWFzay5oPg0KKyNpbmNsdWRlIDxs aW51eC9wcmN0bC5oPg0KKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPg0KKw0KK3N0cnVjdCB0YXNr X3N0cnVjdDsNCisNCisjaWZkZWYgQ09ORklHX1RBU0tfSVNPTEFUSU9ODQorDQoraW50IHRhc2tf aXNvbGF0aW9uX21lc3NhZ2UoaW50IGNwdSwgaW50IGxldmVsLCBib29sIHN1cHAsIGNvbnN0IGNo YXIgKmZtdCwgLi4uKTsNCisNCisjZGVmaW5lIHByX3Rhc2tfaXNvbF9lbWVyZyhjcHUsIGZtdCwg Li4uKQkJCVwNCisJdGFza19pc29sYXRpb25fbWVzc2FnZShjcHUsIExPR0xFVkVMX0VNRVJHLCBm YWxzZSwgZm10LCAjI19fVkFfQVJHU19fKQ0KKyNkZWZpbmUgcHJfdGFza19pc29sX2FsZXJ0KGNw dSwgZm10LCAuLi4pCQkJXA0KKwl0YXNrX2lzb2xhdGlvbl9tZXNzYWdlKGNwdSwgTE9HTEVWRUxf QUxFUlQsIGZhbHNlLCBmbXQsICMjX19WQV9BUkdTX18pDQorI2RlZmluZSBwcl90YXNrX2lzb2xf Y3JpdChjcHUsIGZtdCwgLi4uKQkJCVwNCisJdGFza19pc29sYXRpb25fbWVzc2FnZShjcHUsIExP R0xFVkVMX0NSSVQsIGZhbHNlLCBmbXQsICMjX19WQV9BUkdTX18pDQorI2RlZmluZSBwcl90YXNr X2lzb2xfZXJyKGNwdSwgZm10LCAuLi4pCQkJCVwNCisJdGFza19pc29sYXRpb25fbWVzc2FnZShj cHUsIExPR0xFVkVMX0VSUiwgZmFsc2UsIGZtdCwgIyNfX1ZBX0FSR1NfXykNCisjZGVmaW5lIHBy X3Rhc2tfaXNvbF93YXJuKGNwdSwgZm10LCAuLi4pCQkJXA0KKwl0YXNrX2lzb2xhdGlvbl9tZXNz YWdlKGNwdSwgTE9HTEVWRUxfV0FSTklORywgZmFsc2UsIGZtdCwgIyNfX1ZBX0FSR1NfXykNCisj ZGVmaW5lIHByX3Rhc2tfaXNvbF9ub3RpY2UoY3B1LCBmbXQsIC4uLikJCQlcDQorCXRhc2tfaXNv bGF0aW9uX21lc3NhZ2UoY3B1LCBMT0dMRVZFTF9OT1RJQ0UsIGZhbHNlLCBmbXQsICMjX19WQV9B UkdTX18pDQorI2RlZmluZSBwcl90YXNrX2lzb2xfaW5mbyhjcHUsIGZtdCwgLi4uKQkJCVwNCisJ dGFza19pc29sYXRpb25fbWVzc2FnZShjcHUsIExPR0xFVkVMX0lORk8sIGZhbHNlLCBmbXQsICMj X19WQV9BUkdTX18pDQorI2RlZmluZSBwcl90YXNrX2lzb2xfZGVidWcoY3B1LCBmbXQsIC4uLikJ CQlcDQorCXRhc2tfaXNvbGF0aW9uX21lc3NhZ2UoY3B1LCBMT0dMRVZFTF9ERUJVRywgZmFsc2Us IGZtdCwgIyNfX1ZBX0FSR1NfXykNCisNCisjZGVmaW5lIHByX3Rhc2tfaXNvbF9lbWVyZ19zdXBw KGNwdSwgZm10LCAuLi4pCQkJXA0KKwl0YXNrX2lzb2xhdGlvbl9tZXNzYWdlKGNwdSwgTE9HTEVW RUxfRU1FUkcsIHRydWUsIGZtdCwgIyNfX1ZBX0FSR1NfXykNCisjZGVmaW5lIHByX3Rhc2tfaXNv bF9hbGVydF9zdXBwKGNwdSwgZm10LCAuLi4pCQkJXA0KKwl0YXNrX2lzb2xhdGlvbl9tZXNzYWdl KGNwdSwgTE9HTEVWRUxfQUxFUlQsIHRydWUsIGZtdCwgIyNfX1ZBX0FSR1NfXykNCisjZGVmaW5l IHByX3Rhc2tfaXNvbF9jcml0X3N1cHAoY3B1LCBmbXQsIC4uLikJCQlcDQorCXRhc2tfaXNvbGF0 aW9uX21lc3NhZ2UoY3B1LCBMT0dMRVZFTF9DUklULCB0cnVlLCBmbXQsICMjX19WQV9BUkdTX18p DQorI2RlZmluZSBwcl90YXNrX2lzb2xfZXJyX3N1cHAoY3B1LCBmbXQsIC4uLikJCQkJXA0KKwl0 YXNrX2lzb2xhdGlvbl9tZXNzYWdlKGNwdSwgTE9HTEVWRUxfRVJSLCB0cnVlLCBmbXQsICMjX19W QV9BUkdTX18pDQorI2RlZmluZSBwcl90YXNrX2lzb2xfd2Fybl9zdXBwKGNwdSwgZm10LCAuLi4p CQkJXA0KKwl0YXNrX2lzb2xhdGlvbl9tZXNzYWdlKGNwdSwgTE9HTEVWRUxfV0FSTklORywgdHJ1 ZSwgZm10LCAjI19fVkFfQVJHU19fKQ0KKyNkZWZpbmUgcHJfdGFza19pc29sX25vdGljZV9zdXBw KGNwdSwgZm10LCAuLi4pCQkJXA0KKwl0YXNrX2lzb2xhdGlvbl9tZXNzYWdlKGNwdSwgTE9HTEVW RUxfTk9USUNFLCB0cnVlLCBmbXQsICMjX19WQV9BUkdTX18pDQorI2RlZmluZSBwcl90YXNrX2lz b2xfaW5mb19zdXBwKGNwdSwgZm10LCAuLi4pCQkJXA0KKwl0YXNrX2lzb2xhdGlvbl9tZXNzYWdl KGNwdSwgTE9HTEVWRUxfSU5GTywgdHJ1ZSwgZm10LCAjI19fVkFfQVJHU19fKQ0KKyNkZWZpbmUg cHJfdGFza19pc29sX2RlYnVnX3N1cHAoY3B1LCBmbXQsIC4uLikJCQlcDQorCXRhc2tfaXNvbGF0 aW9uX21lc3NhZ2UoY3B1LCBMT0dMRVZFTF9ERUJVRywgdHJ1ZSwgZm10LCAjI19fVkFfQVJHU19f KQ0KK0RFQ0xBUkVfUEVSX0NQVSh1bnNpZ25lZCBsb25nLCB0c2tfdGhyZWFkX2ZsYWdzX2NvcHkp Ow0KK2V4dGVybiBjcHVtYXNrX3Zhcl90IHRhc2tfaXNvbGF0aW9uX21hcDsNCisNCisvKioNCisg KiB0YXNrX2lzb2xhdGlvbl9yZXF1ZXN0KCkgLSBwcmN0bCBob29rIHRvIHJlcXVlc3QgdGFzayBp c29sYXRpb24NCisgKiBAZmxhZ3M6CUZsYWdzIGZyb20gPGxpbnV4L3ByY3RsLmg+IFBSX1RBU0tf SVNPTEFUSU9OX3h4eC4NCisgKg0KKyAqIFRoaXMgaXMgY2FsbGVkIGZyb20gdGhlIGdlbmVyaWMg cHJjdGwoKSBjb2RlIGZvciBQUl9UQVNLX0lTT0xBVElPTi4NCisgKg0KKyAqIFJldHVybjogUmV0 dXJucyAwIHdoZW4gdGFzayBpc29sYXRpb24gZW5hYmxlZCwgb3RoZXJ3aXNlIGEgbmVnYXRpdmUN CisgKiBlcnJuby4NCisgKi8NCitleHRlcm4gaW50IHRhc2tfaXNvbGF0aW9uX3JlcXVlc3QodW5z aWduZWQgaW50IGZsYWdzKTsNCitleHRlcm4gdm9pZCB0YXNrX2lzb2xhdGlvbl9jcHVfY2xlYW51 cCh2b2lkKTsNCisvKioNCisgKiB0YXNrX2lzb2xhdGlvbl9zdGFydCgpIC0gYXR0ZW1wdCB0byBh Y3R1YWxseSBzdGFydCB0YXNrIGlzb2xhdGlvbg0KKyAqDQorICogVGhpcyBmdW5jdGlvbiBzaG91 bGQgYmUgaW52b2tlZCBhcyB0aGUgbGFzdCB0aGluZyBwcmlvciB0byByZXR1cm5pbmcgdG8NCisg KiB1c2VyIHNwYWNlIGlmIFRJRl9UQVNLX0lTT0xBVElPTiBpcyBzZXQgaW4gdGhlIHRocmVhZF9p bmZvIGZsYWdzLiAgSXQNCisgKiB3aWxsIGF0dGVtcHQgdG8gcXVpZXNjZSB0aGUgY29yZSBhbmQg ZW50ZXIgdGFzay1pc29sYXRpb24gbW9kZS4gIElmIGl0DQorICogZmFpbHMsIGl0IHdpbGwgcmVz ZXQgdGhlIHN5c3RlbSBjYWxsIHJldHVybiB2YWx1ZSB0byBhbiBlcnJvciBjb2RlIHRoYXQNCisg KiBpbmRpY2F0ZXMgdGhlIGZhaWx1cmUgbW9kZS4NCisgKi8NCitleHRlcm4gdm9pZCB0YXNrX2lz b2xhdGlvbl9zdGFydCh2b2lkKTsNCisNCisvKioNCisgKiBpc19pc29sYXRpb25fY3B1KCkgLSBj aGVjayBpZiBDUFUgaXMgaW50ZW5kZWQgZm9yIHJ1bm5pbmcgaXNvbGF0ZWQgdGFza3MuDQorICog QGNwdToJQ1BVIHRvIGNoZWNrLg0KKyAqLw0KK3N0YXRpYyBpbmxpbmUgYm9vbCBpc19pc29sYXRp b25fY3B1KGludCBjcHUpDQorew0KKwlyZXR1cm4gdGFza19pc29sYXRpb25fbWFwICE9IE5VTEwg JiYNCisJCWNwdW1hc2tfdGVzdF9jcHUoY3B1LCB0YXNrX2lzb2xhdGlvbl9tYXApOw0KK30NCisN CisvKioNCisgKiB0YXNrX2lzb2xhdGlvbl9vbl9jcHUoKSAtIGNoZWNrIGlmIHRoZSBjcHUgaXMg cnVubmluZyBpc29sYXRlZCB0YXNrDQorICogQGNwdToJQ1BVIHRvIGNoZWNrLg0KKyAqLw0KK2V4 dGVybiBpbnQgdGFza19pc29sYXRpb25fb25fY3B1KGludCBjcHUpOw0KK2V4dGVybiB2b2lkIHRh c2tfaXNvbGF0aW9uX2NoZWNrX3J1bl9jbGVhbnVwKHZvaWQpOw0KKw0KKy8qKg0KKyAqIHRhc2tf aXNvbGF0aW9uX2NwdW1hc2soKSAtIHNldCBDUFVzIGN1cnJlbnRseSBydW5uaW5nIGlzb2xhdGVk IHRhc2tzDQorICogQG1hc2s6CU1hc2sgdG8gbW9kaWZ5Lg0KKyAqLw0KK2V4dGVybiB2b2lkIHRh c2tfaXNvbGF0aW9uX2NwdW1hc2soc3RydWN0IGNwdW1hc2sgKm1hc2spOw0KKw0KKy8qKg0KKyAq IHRhc2tfaXNvbGF0aW9uX2NsZWFyX2NwdW1hc2soKSAtIGNsZWFyIENQVXMgY3VycmVudGx5IHJ1 bm5pbmcgaXNvbGF0ZWQgdGFza3MNCisgKiBAbWFzazogICAgICBNYXNrIHRvIG1vZGlmeS4NCisg Ki8NCitleHRlcm4gdm9pZCB0YXNrX2lzb2xhdGlvbl9jbGVhcl9jcHVtYXNrKHN0cnVjdCBjcHVt YXNrICptYXNrKTsNCisNCisvKioNCisgKiB0YXNrX2lzb2xhdGlvbl9zeXNjYWxsKCkgLSByZXBv cnQgYSBzeXNjYWxsIGZyb20gYW4gaXNvbGF0ZWQgdGFzaw0KKyAqIEBucjoJCVRoZSBzeXNjYWxs IG51bWJlci4NCisgKg0KKyAqIFRoaXMgcm91dGluZSBzaG91bGQgYmUgaW52b2tlZCBhdCBzeXNj YWxsIGVudHJ5IGlmIFRJRl9UQVNLX0lTT0xBVElPTiBpcw0KKyAqIHNldCBpbiB0aGUgdGhyZWFk X2luZm8gZmxhZ3MuICBJdCBjaGVja3MgZm9yIHZhbGlkIHN5c2NhbGxzLA0KKyAqIHNwZWNpZmlj YWxseSBwcmN0bCgpIHdpdGggUFJfVEFTS19JU09MQVRJT04sIGV4aXQoKSwgYW5kIGV4aXRfZ3Jv dXAoKS4NCisgKiBGb3IgYW55IG90aGVyIHN5c2NhbGwgaXQgd2lsbCByYWlzZSBhIHNpZ25hbCBh bmQgcmV0dXJuIGZhaWx1cmUuDQorICoNCisgKiBSZXR1cm46IDAgZm9yIGFjY2VwdGFibGUgc3lz Y2FsbHMsIC0xIGZvciBhbGwgb3RoZXJzLg0KKyAqLw0KK2V4dGVybiBpbnQgdGFza19pc29sYXRp b25fc3lzY2FsbChpbnQgbnIpOw0KKw0KKy8qKg0KKyAqIF90YXNrX2lzb2xhdGlvbl9pbnRlcnJ1 cHQoKSAtIHJlcG9ydCBhbiBpbnRlcnJ1cHQgb2YgYW4gaXNvbGF0ZWQgdGFzaw0KKyAqIEBmbXQ6 CUEgZm9ybWF0IHN0cmluZyBkZXNjcmliaW5nIHRoZSBpbnRlcnJ1cHQNCisgKiBALi4uOglGb3Jt YXQgYXJndW1lbnRzLCBpZiBhbnkuDQorICoNCisgKiBUaGlzIHJvdXRpbmUgc2hvdWxkIGJlIGlu dm9rZWQgYXQgYW55IGV4Y2VwdGlvbiBvciBJUlEgaWYNCisgKiBUSUZfVEFTS19JU09MQVRJT04g aXMgc2V0IGluIHRoZSB0aHJlYWRfaW5mbyBmbGFncy4gIEl0IGlzIG5vdCBuZWNlc3NhcnkNCisg KiB0byBpbnZva2UgaXQgaWYgdGhlIGV4Y2VwdGlvbiB3aWxsIGdlbmVyYXRlIGEgc2lnbmFsIGFu eXdheSAoZS5nLiBhIGJhZA0KKyAqIHBhZ2UgZmF1bHQpLCBhbmQgaW4gdGhhdCBjYXNlIGl0IGlz IHByZWZlcmFibGUgbm90IHRvIGludm9rZSBpdCBidXQganVzdA0KKyAqIHJlbHkgb24gdGhlIHN0 YW5kYXJkIExpbnV4IHNpZ25hbC4gIFRoZSBtYWNybyB0YXNrX2lzb2xhdGlvbl9zeXNjYWxsKCkN CisgKiB3cmFwcyB0aGUgVElGX1RBU0tfSVNPTEFUSU9OIGZsYWcgdGVzdCB0byBzaW1wbGlmeSB0 aGUgY2FsbGVyIGNvZGUuDQorICovDQorZXh0ZXJuIHZvaWQgX3Rhc2tfaXNvbGF0aW9uX2ludGVy cnVwdChjb25zdCBjaGFyICpmbXQsIC4uLik7DQorI2RlZmluZSB0YXNrX2lzb2xhdGlvbl9pbnRl cnJ1cHQoZm10LCAuLi4pCQkJCVwNCisJZG8gewkJCQkJCQkJXA0KKwkJaWYgKGN1cnJlbnRfdGhy ZWFkX2luZm8oKS0+ZmxhZ3MgJiBfVElGX1RBU0tfSVNPTEFUSU9OKQlcDQorCQkJX3Rhc2tfaXNv bGF0aW9uX2ludGVycnVwdChmbXQsICMjIF9fVkFfQVJHU19fKTsJXA0KKwl9IHdoaWxlICgwKQ0K Kw0KKy8qKg0KKyAqIHRhc2tfaXNvbGF0aW9uX3JlbW90ZSgpIC0gcmVwb3J0IGEgcmVtb3RlIGlu dGVycnVwdCBvZiBhbiBpc29sYXRlZCB0YXNrDQorICogQGNwdToJVGhlIHJlbW90ZSBjcHUgdGhh dCBpcyBhYm91dCB0byBiZSBpbnRlcnJ1cHRlZC4NCisgKiBAZm10OglBIGZvcm1hdCBzdHJpbmcg ZGVzY3JpYmluZyB0aGUgaW50ZXJydXB0DQorICogQC4uLjoJRm9ybWF0IGFyZ3VtZW50cywgaWYg YW55Lg0KKyAqDQorICogVGhpcyByb3V0aW5lIHNob3VsZCBiZSBpbnZva2VkIGFueSB0aW1lIGEg cmVtb3RlIElQSSBvciBvdGhlciB0eXBlIG9mDQorICogaW50ZXJydXB0IGlzIGJlaW5nIGRlbGl2 ZXJlZCB0byBhbm90aGVyIGNwdS4gVGhlIGZ1bmN0aW9uIHdpbGwgY2hlY2sgdG8NCisgKiBzZWUg aWYgdGhlIHRhcmdldCBjb3JlIGlzIHJ1bm5pbmcgYSB0YXNrLWlzb2xhdGlvbiB0YXNrLCBhbmQg Z2VuZXJhdGUgYQ0KKyAqIGRpYWdub3N0aWMgb24gdGhlIGNvbnNvbGUgaWYgc287IGluIGFkZGl0 aW9uLCB3ZSB0YWcgdGhlIHRhc2sgc28gaXQNCisgKiBkb2Vzbid0IGdlbmVyYXRlIGFub3RoZXIg ZGlhZ25vc3RpYyB3aGVuIHRoZSBpbnRlcnJ1cHQgYWN0dWFsbHkgYXJyaXZlcy4NCisgKiBHZW5l cmF0aW5nIGEgZGlhZ25vc3RpYyByZW1vdGVseSB5aWVsZHMgYSBjbGVhcmVyIGluZGljYXRpb24g b2Ygd2hhdA0KKyAqIGhhcHBlbmVkIHRoZW4ganVzdCByZXBvcnRpbmcgb25seSB3aGVuIHRoZSBy ZW1vdGUgY29yZSBpcyBpbnRlcnJ1cHRlZC4NCisgKg0KKyAqLw0KK2V4dGVybiB2b2lkIHRhc2tf aXNvbGF0aW9uX3JlbW90ZShpbnQgY3B1LCBjb25zdCBjaGFyICpmbXQsIC4uLik7DQorDQorLyoq DQorICogdGFza19pc29sYXRpb25fcmVtb3RlX2NwdW1hc2soKSAtIHJlcG9ydCBpbnRlcnJ1cHRp b24gb2YgbXVsdGlwbGUgY3B1cw0KKyAqIEBtYXNrOglUaGUgc2V0IG9mIHJlbW90ZXMgY3B1cyB0 aGF0IGFyZSBhYm91dCB0byBiZSBpbnRlcnJ1cHRlZC4NCisgKiBAZm10OglBIGZvcm1hdCBzdHJp bmcgZGVzY3JpYmluZyB0aGUgaW50ZXJydXB0DQorICogQC4uLjoJRm9ybWF0IGFyZ3VtZW50cywg aWYgYW55Lg0KKyAqDQorICogVGhpcyBpcyB0aGUgY3B1bWFzayB2YXJpYW50IG9mIF90YXNrX2lz b2xhdGlvbl9yZW1vdGUoKS4gIFdlDQorICogZ2VuZXJhdGUgYSBzaW5nbGUtbGluZSBkaWFnbm9z dGljIG1lc3NhZ2UgZXZlbiBpZiBtdWx0aXBsZSByZW1vdGUNCisgKiB0YXNrLWlzb2xhdGlvbiBj cHVzIGFyZSBiZWluZyBpbnRlcnJ1cHRlZC4NCisgKi8NCitleHRlcm4gdm9pZCB0YXNrX2lzb2xh dGlvbl9yZW1vdGVfY3B1bWFzayhjb25zdCBzdHJ1Y3QgY3B1bWFzayAqbWFzaywNCisJCQkJCSAg Y29uc3QgY2hhciAqZm10LCAuLi4pOw0KKw0KKy8qKg0KKyAqIF90YXNrX2lzb2xhdGlvbl9zaWdu YWwoKSAtIGRpc2FibGUgdGFzayBpc29sYXRpb24gd2hlbiBzaWduYWwgaXMgcGVuZGluZw0KKyAq IEB0YXNrOglUaGUgdGFzayBmb3Igd2hpY2ggdG8gZGlzYWJsZSBpc29sYXRpb24uDQorICoNCisg KiBUaGlzIGZ1bmN0aW9uIGdlbmVyYXRlcyBhIGRpYWdub3N0aWMgYW5kIGRpc2FibGVzIHRhc2sg aXNvbGF0aW9uOyBpdA0KKyAqIHNob3VsZCBiZSBjYWxsZWQgaWYgVElGX1RBU0tfSVNPTEFUSU9O IGlzIHNldCB3aGVuIG5vdGlmeWluZyBhIHRhc2sgb2YgYQ0KKyAqIHBlbmRpbmcgc2lnbmFsLiAg VGhlIHRhc2tfaXNvbGF0aW9uX2ludGVycnVwdCgpIGZ1bmN0aW9uIG5vcm1hbGx5DQorICogZ2Vu ZXJhdGVzIGEgZGlhZ25vc3RpYyBmb3IgZXZlbnRzIHRoYXQganVzdCBpbnRlcnJ1cHQgYSB0YXNr IHdpdGhvdXQNCisgKiBnZW5lcmF0aW5nIGEgc2lnbmFsOyBoZXJlIHdlIG5lZWQgdG8gaG9vayB0 aGUgcGF0aHMgdGhhdCBjb3JyZXNwb25kIHRvDQorICogaW50ZXJydXB0cyB0aGF0IGRvIGdlbmVy YXRlIGEgc2lnbmFsLiAgVGhlIG1hY3JvIHRhc2tfaXNvbGF0aW9uX3NpZ25hbCgpDQorICogd3Jh cHMgdGhlIFRJRl9UQVNLX0lTT0xBVElPTiBmbGFnIHRlc3QgdG8gc2ltcGxpZnkgdGhlIGNhbGxl ciBjb2RlLg0KKyAqLw0KK2V4dGVybiB2b2lkIF90YXNrX2lzb2xhdGlvbl9zaWduYWwoc3RydWN0 IHRhc2tfc3RydWN0ICp0YXNrKTsNCisjZGVmaW5lIHRhc2tfaXNvbGF0aW9uX3NpZ25hbCh0YXNr KQkJCQkJXA0KKwlkbyB7CQkJCQkJCQlcDQorCQlpZiAodGFza190aHJlYWRfaW5mbyh0YXNrKS0+ ZmxhZ3MgJiBfVElGX1RBU0tfSVNPTEFUSU9OKSBcDQorCQkJX3Rhc2tfaXNvbGF0aW9uX3NpZ25h bCh0YXNrKTsJCQlcDQorCX0gd2hpbGUgKDApDQorDQorLyoqDQorICogdGFza19pc29sYXRpb25f dXNlcl9leGl0KCkgLSBkZWJ1ZyBhbGwgdXNlcl9leGl0IGNhbGxzDQorICoNCisgKiBCeSBkZWZh dWx0LCB3ZSBkb24ndCBnZW5lcmF0ZSBhbiBleGNlcHRpb24gaW4gdGhlIGxvdy1sZXZlbCB1c2Vy X2V4aXQoKQ0KKyAqIGNvZGUsIGJlY2F1c2UgcHJvZ3JhbXMgbG9zZSB0aGUgYWJpbGl0eSB0byBk aXNhYmxlIHRhc2sgaXNvbGF0aW9uOiB0aGUNCisgKiB1c2VyX2V4aXQoKSBob29rIHdpbGwgY2F1 c2UgYSBzaWduYWwgcHJpb3IgdG8gdGFza19pc29sYXRpb25fc3lzY2FsbCgpDQorICogZGlzYWJs aW5nIHRhc2sgaXNvbGF0aW9uLiAgSW4gYWRkaXRpb24sIGl0IG1lYW5zIHRoYXQgd2UgbG9zZSBh bGwgdGhlDQorICogZGlhZ25vc3RpYyBpbmZvIG90aGVyd2lzZSBhdmFpbGFibGUgZnJvbSB0YXNr X2lzb2xhdGlvbl9pbnRlcnJ1cHQoKSBob29rcw0KKyAqIGxhdGVyIGluIHRoZSBpbnRlcnJ1cHQt aGFuZGxpbmcgcHJvY2Vzcy4gIEJ1dCB5b3UgbWF5IGVuYWJsZSBpdCBoZXJlIGZvcg0KKyAqIGEg c3BlY2lhbCBrZXJuZWwgYnVpbGQgaWYgeW91IGFyZSBoYXZpbmcgdW5kaWFnbm9zZWQgdXNlcnNw YWNlIGppdHRlci4NCisgKi8NCitzdGF0aWMgaW5saW5lIHZvaWQgdGFza19pc29sYXRpb25fdXNl cl9leGl0KHZvaWQpDQorew0KKyNpZmRlZiBERUJVR19UQVNLX0lTT0xBVElPTg0KKwl0YXNrX2lz b2xhdGlvbl9pbnRlcnJ1cHQoInVzZXJfZXhpdCIpOw0KKyNlbmRpZg0KK30NCisNCisjZWxzZSAv KiAhQ09ORklHX1RBU0tfSVNPTEFUSU9OICovDQorc3RhdGljIGlubGluZSBpbnQgdGFza19pc29s YXRpb25fcmVxdWVzdCh1bnNpZ25lZCBpbnQgZmxhZ3MpIHsgcmV0dXJuIC1FSU5WQUw7IH0NCitz dGF0aWMgaW5saW5lIHZvaWQgdGFza19pc29sYXRpb25fc3RhcnQodm9pZCkgeyB9DQorc3RhdGlj IGlubGluZSBib29sIGlzX2lzb2xhdGlvbl9jcHUoaW50IGNwdSkgeyByZXR1cm4gMDsgfQ0KK3N0 YXRpYyBpbmxpbmUgaW50IHRhc2tfaXNvbGF0aW9uX29uX2NwdShpbnQgY3B1KSB7IHJldHVybiAw OyB9DQorc3RhdGljIGlubGluZSB2b2lkIHRhc2tfaXNvbGF0aW9uX2NwdW1hc2soc3RydWN0IGNw dW1hc2sgKm1hc2spIHsgfQ0KK3N0YXRpYyBpbmxpbmUgdm9pZCB0YXNrX2lzb2xhdGlvbl9jbGVh cl9jcHVtYXNrKHN0cnVjdCBjcHVtYXNrICptYXNrKSB7IH0NCitzdGF0aWMgaW5saW5lIHZvaWQg dGFza19pc29sYXRpb25fY3B1X2NsZWFudXAodm9pZCkgeyB9DQorc3RhdGljIGlubGluZSB2b2lk IHRhc2tfaXNvbGF0aW9uX2NoZWNrX3J1bl9jbGVhbnVwKHZvaWQpIHsgfQ0KK3N0YXRpYyBpbmxp bmUgaW50IHRhc2tfaXNvbGF0aW9uX3N5c2NhbGwoaW50IG5yKSB7IHJldHVybiAwOyB9DQorc3Rh dGljIGlubGluZSB2b2lkIHRhc2tfaXNvbGF0aW9uX2ludGVycnVwdChjb25zdCBjaGFyICpmbXQs IC4uLikgeyB9DQorc3RhdGljIGlubGluZSB2b2lkIHRhc2tfaXNvbGF0aW9uX3JlbW90ZShpbnQg Y3B1LCBjb25zdCBjaGFyICpmbXQsIC4uLikgeyB9DQorc3RhdGljIGlubGluZSB2b2lkIHRhc2tf aXNvbGF0aW9uX3JlbW90ZV9jcHVtYXNrKGNvbnN0IHN0cnVjdCBjcHVtYXNrICptYXNrLA0KKwkJ CQkJCSBjb25zdCBjaGFyICpmbXQsIC4uLikgeyB9DQorc3RhdGljIGlubGluZSB2b2lkIHRhc2tf aXNvbGF0aW9uX3NpZ25hbChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spIHsgfQ0KK3N0YXRpYyBp bmxpbmUgdm9pZCB0YXNrX2lzb2xhdGlvbl91c2VyX2V4aXQodm9pZCkgeyB9DQorI2VuZGlmDQor DQorI2VuZGlmIC8qIF9MSU5VWF9JU09MQVRJT05fSCAqLw0KZGlmZiAtLWdpdCBhL2luY2x1ZGUv bGludXgvc2NoZWQuaCBiL2luY2x1ZGUvbGludXgvc2NoZWQuaA0KaW5kZXggMDQyNzg0OTNiZjE1 Li41MmZkYjMyYWEzYjkgMTAwNjQ0DQotLS0gYS9pbmNsdWRlL2xpbnV4L3NjaGVkLmgNCisrKyBi L2luY2x1ZGUvbGludXgvc2NoZWQuaA0KQEAgLTEyODAsNiArMTI4MCwxMCBAQCBzdHJ1Y3QgdGFz a19zdHJ1Y3Qgew0KIAl1bnNpZ25lZCBsb25nCQkJbG93ZXN0X3N0YWNrOw0KIAl1bnNpZ25lZCBs b25nCQkJcHJldl9sb3dlc3Rfc3RhY2s7DQogI2VuZGlmDQorI2lmZGVmIENPTkZJR19UQVNLX0lT T0xBVElPTg0KKwl1bnNpZ25lZCBzaG9ydAkJCXRhc2tfaXNvbGF0aW9uX2ZsYWdzOyAgLyogcHJj dGwgKi8NCisJdW5zaWduZWQgc2hvcnQJCQl0YXNrX2lzb2xhdGlvbl9zdGF0ZTsNCisjZW5kaWYN CiANCiAJLyoNCiAJICogTmV3IGZpZWxkcyBmb3IgdGFza19zdHJ1Y3Qgc2hvdWxkIGJlIGFkZGVk IGFib3ZlIGhlcmUsIHNvIHRoYXQNCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3RpY2suaCBi L2luY2x1ZGUvbGludXgvdGljay5oDQppbmRleCA3MzQwNjEzYzdlZmYuLjI3YzdjMDMzZDVhOCAx MDA2NDQNCi0tLSBhL2luY2x1ZGUvbGludXgvdGljay5oDQorKysgYi9pbmNsdWRlL2xpbnV4L3Rp Y2suaA0KQEAgLTI2OCw2ICsyNjgsOSBAQCBzdGF0aWMgaW5saW5lIHZvaWQgdGlja19kZXBfY2xl YXJfc2lnbmFsKHN0cnVjdCBzaWduYWxfc3RydWN0ICpzaWduYWwsDQogZXh0ZXJuIHZvaWQgdGlj a19ub2h6X2Z1bGxfa2lja19jcHUoaW50IGNwdSk7DQogZXh0ZXJuIHZvaWQgX190aWNrX25vaHpf dGFza19zd2l0Y2godm9pZCk7DQogZXh0ZXJuIHZvaWQgX19pbml0IHRpY2tfbm9oel9mdWxsX3Nl dHVwKGNwdW1hc2tfdmFyX3QgY3B1bWFzayk7DQorI2lmZGVmIENPTkZJR19UQVNLX0lTT0xBVElP Tg0KK2V4dGVybiBpbnQgdHJ5X3N0b3BfZnVsbF90aWNrKHZvaWQpOw0KKyNlbmRpZg0KICNlbHNl DQogc3RhdGljIGlubGluZSBib29sIHRpY2tfbm9oel9mdWxsX2VuYWJsZWQodm9pZCkgeyByZXR1 cm4gZmFsc2U7IH0NCiBzdGF0aWMgaW5saW5lIGJvb2wgdGlja19ub2h6X2Z1bGxfY3B1KGludCBj cHUpIHsgcmV0dXJuIGZhbHNlOyB9DQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2xpbnV4L3By Y3RsLmggYi9pbmNsdWRlL3VhcGkvbGludXgvcHJjdGwuaA0KaW5kZXggMDdiNGY4MTMxZTM2Li5m NDg0OGVkMmEwNjkgMTAwNjQ0DQotLS0gYS9pbmNsdWRlL3VhcGkvbGludXgvcHJjdGwuaA0KKysr IGIvaW5jbHVkZS91YXBpL2xpbnV4L3ByY3RsLmgNCkBAIC0yMzgsNCArMjM4LDEwIEBAIHN0cnVj dCBwcmN0bF9tbV9tYXAgew0KICNkZWZpbmUgUFJfU0VUX0lPX0ZMVVNIRVIJCTU3DQogI2RlZmlu ZSBQUl9HRVRfSU9fRkxVU0hFUgkJNTgNCiANCisvKiBFbmFibGUgdGFza19pc29sYXRpb24gbW9k ZSBmb3IgVEFTS19JU09MQVRJT04ga2VybmVscy4gKi8NCisjZGVmaW5lIFBSX1RBU0tfSVNPTEFU SU9OCQk0OA0KKyMgZGVmaW5lIFBSX1RBU0tfSVNPTEFUSU9OX0VOQUJMRQkoMSA8PCAwKQ0KKyMg ZGVmaW5lIFBSX1RBU0tfSVNPTEFUSU9OX1NFVF9TSUcoc2lnKQkoKChzaWcpICYgMHg3ZikgPDwg OCkNCisjIGRlZmluZSBQUl9UQVNLX0lTT0xBVElPTl9HRVRfU0lHKGJpdHMpICgoKGJpdHMpID4+ IDgpICYgMHg3ZikNCisNCiAjZW5kaWYgLyogX0xJTlVYX1BSQ1RMX0ggKi8NCmRpZmYgLS1naXQg YS9pbml0L0tjb25maWcgYi9pbml0L0tjb25maWcNCmluZGV4IDIwYTZhYzMzNzYxYy4uZWNkZjU2 N2Y2YmQ0IDEwMDY0NA0KLS0tIGEvaW5pdC9LY29uZmlnDQorKysgYi9pbml0L0tjb25maWcNCkBA IC01NzYsNiArNTc2LDM0IEBAIGNvbmZpZyBDUFVfSVNPTEFUSU9ODQogDQogc291cmNlICJrZXJu ZWwvcmN1L0tjb25maWciDQogDQorY29uZmlnIEhBVkVfQVJDSF9UQVNLX0lTT0xBVElPTg0KKwli b29sDQorDQorY29uZmlnIFRBU0tfSVNPTEFUSU9ODQorCWJvb2wgIlByb3ZpZGUgaGFyZCBDUFUg aXNvbGF0aW9uIGZyb20gdGhlIGtlcm5lbCBvbiBkZW1hbmQiDQorCWRlcGVuZHMgb24gTk9fSFpf RlVMTCAmJiBIQVZFX0FSQ0hfVEFTS19JU09MQVRJT04NCisJaGVscA0KKw0KKwlBbGxvdyB1c2Vy c3BhY2UgcHJvY2Vzc2VzIHRoYXQgcGxhY2UgdGhlbXNlbHZlcyBvbiBjb3JlcyB3aXRoDQorCW5v aHpfZnVsbCBhbmQgaXNvbGNwdXMgZW5hYmxlZCwgYW5kIHJ1biBwcmN0bChQUl9UQVNLX0lTT0xB VElPTiksDQorCXRvICJpc29sYXRlIiB0aGVtc2VsdmVzIGZyb20gdGhlIGtlcm5lbC4gIFByaW9y IHRvIHJldHVybmluZyB0bw0KKwl1c2Vyc3BhY2UsIGlzb2xhdGVkIHRhc2tzIHdpbGwgYXJyYW5n ZSB0aGF0IG5vIGZ1dHVyZSBrZXJuZWwNCisJYWN0aXZpdHkgd2lsbCBpbnRlcnJ1cHQgdGhlIHRh c2sgd2hpbGUgdGhlIHRhc2sgaXMgcnVubmluZyBpbg0KKwl1c2Vyc3BhY2UuICBBdHRlbXB0aW5n IHRvIHJlLWVudGVyIHRoZSBrZXJuZWwgd2hpbGUgaW4gdGhpcyBtb2RlDQorCXdpbGwgY2F1c2Ug dGhlIHRhc2sgdG8gYmUgdGVybWluYXRlZCB3aXRoIGEgc2lnbmFsOyB5b3UgbXVzdA0KKwlleHBs aWNpdGx5IHVzZSBwcmN0bCgpIHRvIGRpc2FibGUgdGFzayBpc29sYXRpb24gYmVmb3JlIHJlc3Vt aW5nDQorCW5vcm1hbCB1c2Ugb2YgdGhlIGtlcm5lbC4NCisNCisJVGhpcyAiaGFyZCIgaXNvbGF0 aW9uIGZyb20gdGhlIGtlcm5lbCBpcyByZXF1aXJlZCBmb3IgdXNlcnNwYWNlDQorCXRhc2tzIHRo YXQgYXJlIHJ1bm5pbmcgaGFyZCByZWFsLXRpbWUgdGFza3MgaW4gdXNlcnNwYWNlLCBzdWNoIGFz DQorCWEgaGlnaC1zcGVlZCBuZXR3b3JrIGRyaXZlciBpbiB1c2Vyc3BhY2UuICBXaXRob3V0IHRo aXMgb3B0aW9uLCBidXQNCisJd2l0aCBOT19IWl9GVUxMIGVuYWJsZWQsIHRoZSBrZXJuZWwgd2ls bCBtYWtlIGEgYmVzdC1mYWl0aCwgInNvZnQiDQorCWVmZm9ydCB0byBzaGllbGQgYSBzaW5nbGUg dXNlcnNwYWNlIHByb2Nlc3MgZnJvbSBpbnRlcnJ1cHRzLCBidXQNCisJbWFrZXMgbm8gZ3VhcmFu dGVlcy4NCisNCisJWW91IHNob3VsZCBzYXkgIk4iIHVubGVzcyB5b3UgYXJlIGludGVuZGluZyB0 byBydW4gYQ0KKwloaWdoLXBlcmZvcm1hbmNlIHVzZXJzcGFjZSBkcml2ZXIgb3Igc2ltaWxhciB0 YXNrLg0KKw0KIGNvbmZpZyBCVUlMRF9CSU4yQw0KIAlib29sDQogCWRlZmF1bHQgbg0KZGlmZiAt LWdpdCBhL2tlcm5lbC9NYWtlZmlsZSBiL2tlcm5lbC9NYWtlZmlsZQ0KaW5kZXggNGNiNDEzMGNl ZDMyLi4yZjJhZTkxZjkwZDUgMTAwNjQ0DQotLS0gYS9rZXJuZWwvTWFrZWZpbGUNCisrKyBiL2tl cm5lbC9NYWtlZmlsZQ0KQEAgLTEyMiw2ICsxMjIsOCBAQCBvYmotJChDT05GSUdfR0NDX1BMVUdJ Tl9TVEFDS0xFQUspICs9IHN0YWNrbGVhay5vDQogS0FTQU5fU0FOSVRJWkVfc3RhY2tsZWFrLm8g Oj0gbg0KIEtDT1ZfSU5TVFJVTUVOVF9zdGFja2xlYWsubyA6PSBuDQogDQorb2JqLSQoQ09ORklH X1RBU0tfSVNPTEFUSU9OKSArPSBpc29sYXRpb24ubw0KKw0KICQob2JqKS9jb25maWdzLm86ICQo b2JqKS9jb25maWdfZGF0YS5neg0KIA0KIHRhcmdldHMgKz0gY29uZmlnX2RhdGEuZ3oNCmRpZmYg LS1naXQgYS9rZXJuZWwvY29udGV4dF90cmFja2luZy5jIGIva2VybmVsL2NvbnRleHRfdHJhY2tp bmcuYw0KaW5kZXggMDI5NmI0YmRhOGYxLi5lOTIwNjczNmYyMTkgMTAwNjQ0DQotLS0gYS9rZXJu ZWwvY29udGV4dF90cmFja2luZy5jDQorKysgYi9rZXJuZWwvY29udGV4dF90cmFja2luZy5jDQpA QCAtMjEsNiArMjEsNyBAQA0KICNpbmNsdWRlIDxsaW51eC9oYXJkaXJxLmg+DQogI2luY2x1ZGUg PGxpbnV4L2V4cG9ydC5oPg0KICNpbmNsdWRlIDxsaW51eC9rcHJvYmVzLmg+DQorI2luY2x1ZGUg PGxpbnV4L2lzb2xhdGlvbi5oPg0KIA0KICNkZWZpbmUgQ1JFQVRFX1RSQUNFX1BPSU5UUw0KICNp bmNsdWRlIDx0cmFjZS9ldmVudHMvY29udGV4dF90cmFja2luZy5oPg0KQEAgLTE1Nyw2ICsxNTgs NyBAQCB2b2lkIF9fY29udGV4dF90cmFja2luZ19leGl0KGVudW0gY3R4X3N0YXRlIHN0YXRlKQ0K IAkJCWlmIChzdGF0ZSA9PSBDT05URVhUX1VTRVIpIHsNCiAJCQkJdnRpbWVfdXNlcl9leGl0KGN1 cnJlbnQpOw0KIAkJCQl0cmFjZV91c2VyX2V4aXQoMCk7DQorCQkJCXRhc2tfaXNvbGF0aW9uX3Vz ZXJfZXhpdCgpOw0KIAkJCX0NCiAJCX0NCiAJCV9fdGhpc19jcHVfd3JpdGUoY29udGV4dF90cmFj a2luZy5zdGF0ZSwgQ09OVEVYVF9LRVJORUwpOw0KZGlmZiAtLWdpdCBhL2tlcm5lbC9pc29sYXRp b24uYyBiL2tlcm5lbC9pc29sYXRpb24uYw0KbmV3IGZpbGUgbW9kZSAxMDA2NDQNCmluZGV4IDAw MDAwMDAwMDAwMC4uYWUyOTczMmMzNzZjDQotLS0gL2Rldi9udWxsDQorKysgYi9rZXJuZWwvaXNv bGF0aW9uLmMNCkBAIC0wLDAgKzEsNzc0IEBADQorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IEdQTC0yLjAtb25seQ0KKy8qDQorICogIGxpbnV4L2tlcm5lbC9pc29sYXRpb24uYw0KKyAqDQor ICogIEltcGxlbWVudGF0aW9uIG9mIHRhc2sgaXNvbGF0aW9uLg0KKyAqDQorICogQXV0aG9yczoN CisgKiAgIENocmlzIE1ldGNhbGYgPGNtZXRjYWxmQG1lbGxhbm94LmNvbT4NCisgKiAgIEFsZXgg QmVsaXRzIDxhYmVsaXRzQG1hcnZlbGwuY29tPg0KKyAqICAgWXVyaSBOb3JvdiA8eW5vcm92QG1h cnZlbGwuY29tPg0KKyAqLw0KKw0KKyNpbmNsdWRlIDxsaW51eC9tbS5oPg0KKyNpbmNsdWRlIDxs aW51eC9zd2FwLmg+DQorI2luY2x1ZGUgPGxpbnV4L3Ztc3RhdC5oPg0KKyNpbmNsdWRlIDxsaW51 eC9zY2hlZC5oPg0KKyNpbmNsdWRlIDxsaW51eC9pc29sYXRpb24uaD4NCisjaW5jbHVkZSA8bGlu dXgvc3lzY2FsbHMuaD4NCisjaW5jbHVkZSA8bGludXgvc21wLmg+DQorI2luY2x1ZGUgPGxpbnV4 L3RpY2suaD4NCisjaW5jbHVkZSA8YXNtL3VuaXN0ZC5oPg0KKyNpbmNsdWRlIDxhc20vc3lzY2Fs bC5oPg0KKyNpbmNsdWRlIDxsaW51eC9ocnRpbWVyLmg+DQorDQorLyoNCisgKiBUaGVzZSB2YWx1 ZXMgYXJlIHN0b3JlZCBpbiB0YXNrX2lzb2xhdGlvbl9zdGF0ZS4NCisgKiBOb3RlIHRoYXQgU1RB VEVfTk9STUFMICsgVElGX1RBU0tfSVNPTEFUSU9OIG1lYW5zIHdlIGFyZSBzdGlsbA0KKyAqIHJl dHVybmluZyBmcm9tIHN5c19wcmN0bCgpIHRvIHVzZXJzcGFjZS4NCisgKi8NCitlbnVtIHsNCisJ U1RBVEVfTk9STUFMID0gMCwJLyogTm90IGlzb2xhdGVkICovDQorCVNUQVRFX0lTT0xBVEVEID0g MQkvKiBJbiB1c2Vyc3BhY2UsIGlzb2xhdGVkICovDQorfTsNCisNCisvKg0KKyAqIFRoaXMgdmFy aWFibGUgY29udGFpbnMgdGhyZWFkIGZsYWdzIGNvcGllZCBhdCB0aGUgbW9tZW50DQorICogd2hl biBzY2hlZHVsZSgpIHN3aXRjaGVkIHRvIHRoZSB0YXNrIG9uIGEgZ2l2ZW4gQ1BVLA0KKyAqIG9y IDAgaWYgbm8gdGFzayBpcyBydW5uaW5nLg0KKyAqLw0KK0RFRklORV9QRVJfQ1BVKHVuc2lnbmVk IGxvbmcsIHRza190aHJlYWRfZmxhZ3NfY2FjaGUpOw0KKw0KKy8qDQorICogQ291bnRlciBmb3Ig aXNvbGF0aW9uIHN0YXRlIG9uIGEgZ2l2ZW4gQ1BVLCBpbmNyZW1lbnRzIHdoZW4gZW50ZXJpbmcN CisgKiBpc29sYXRpb24gYW5kIGRlY3JlbWVudHMgd2hlbiBleGl0aW5nIGlzb2xhdGlvbiAoYmVm b3JlIG9yIGFmdGVyIHRoZQ0KKyAqIGNsZWFudXApLiBNdWx0aXBsZSBzaW11bHRhbmVvdXNseSBy dW5uaW5nIHByb2NlZHVyZXMgZW50ZXJpbmcgb3INCisgKiBleGl0aW5nIGlzb2xhdGlvbiBhcmUg cHJldmVudGVkIGJ5IGNoZWNraW5nIHRoZSByZXN1bHQgb2YNCisgKiBpbmNyZW1lbnRpbmcgb3Ig ZGVjcmVtZW50aW5nIHRoaXMgdmFyaWFibGUuIFRoaXMgdmFyaWFibGUgaXMgYm90aA0KKyAqIGlu Y3JlbWVudGVkIGFuZCBkZWNyZW1lbnRlZCBieSBDUFUgdGhhdCBjYXVzZWQgaXNvbGF0aW9uIGVu dGVyaW5nIG9yDQorICogZXhpdC4NCisgKg0KKyAqIFRoaXMgaXMgbmVjZXNzYXJ5IGJlY2F1c2Ug bXVsdGlwbGUgaXNvbGF0aW9uLWJyZWFraW5nIGV2ZW50cyBtYXkgaGFwcGVuDQorICogYXQgb25j ZSAob3Igb25lIGFzIHRoZSByZXN1bHQgb2YgdGhlIG90aGVyKSwgaG93ZXZlciBpc29sYXRpb24g ZXhpdA0KKyAqIG1heSBvbmx5IGhhcHBlbiBvbmNlIHRvIHRyYW5zaXRpb24gZnJvbSBpc29sYXRl ZCB0byBub24taXNvbGF0ZWQgc3RhdGUuDQorICogVGhlcmVmb3JlLCBpZiBkZWNyZW1lbnRpbmcg dGhpcyBjb3VudGVyIHJlc3VsdHMgaW4gYSB2YWx1ZSBsZXNzIHRoYW4gMCwNCisgKiBpc29sYXRp b24gZXhpdCBwcm9jZWR1cmUgY2FuJ3QgYmUgc3RhcnRlZCAtLSBpdCBhbHJlYWR5IGhhcHBlbmVk LCBvciBpcw0KKyAqIGluIHByb2dyZXNzLCBvciBpc29sYXRpb24gaXMgbm90IGVudGVyZWQgeWV0 Lg0KKyAqLw0KK0RFRklORV9QRVJfQ1BVKGF0b21pY190LCBpc29sX2NvdW50ZXIpOw0KKw0KKy8q DQorICogRGVzY3JpcHRpb24gb2YgdGhlIGxhc3QgdHdvIHRhc2tzIHRoYXQgcmFuIGlzb2xhdGVk IG9uIGEgZ2l2ZW4gQ1BVLg0KKyAqIFRoaXMgaXMgaW50ZW5kZWQgb25seSBmb3IgbWVzc2FnZXMg YWJvdXQgaXNvbGF0aW9uIGJyZWFraW5nLiBXZQ0KKyAqIGRvbid0IHdhbnQgYW55IHJlZmVyZW5j ZXMgdG8gYWN0dWFsIHRhc2sgd2hpbGUgYWNjZXNzaW5nIHRoaXMgZnJvbQ0KKyAqIENQVSB0aGF0 IGNhdXNlZCBpc29sYXRpb24gYnJlYWtpbmcgLS0gd2Uga25vdyBub3RoaW5nIGFib3V0IHRpbWlu Zw0KKyAqIGFuZCBkb24ndCB3YW50IHRvIHVzZSBsb2NraW5nIG9yIFJDVS4NCisgKi8NCitzdHJ1 Y3QgaXNvbF90YXNrX2Rlc2Mgew0KKwlhdG9taWNfdCBjdXJyX2luZGV4Ow0KKwlhdG9taWNfdCBj dXJyX2luZGV4X3dyOw0KKwlib29sCXdhcm5lZFsyXTsNCisJcGlkX3QJcGlkWzJdOw0KKwlwaWRf dAl0Z2lkWzJdOw0KKwljaGFyCWNvbW1bMl1bVEFTS19DT01NX0xFTl07DQorfTsNCitzdGF0aWMg REVGSU5FX1BFUl9DUFUoc3RydWN0IGlzb2xfdGFza19kZXNjLCBpc29sX3Rhc2tfZGVzY3MpOw0K Kw0KKy8qDQorICogQ291bnRlciBmb3IgaXNvbGF0aW9uIGV4aXRpbmcgcHJvY2VkdXJlcyAoZnJv bSByZXF1ZXN0IHRvIHRoZSBzdGFydCBvZg0KKyAqIGNsZWFudXApIGJlaW5nIGF0dGVtcHRlZCBh dCBvbmNlIG9uIGEgQ1BVLiBOb3JtYWxseSBpbmNyZW1lbnRpbmcgb2YNCisgKiB0aGlzIGNvdW50 ZXIgaXMgcGVyZm9ybWVkIGZyb20gdGhlIENQVSB0aGF0IGNhdXNlZCBpc29sYXRpb24gYnJlYWtp bmcsDQorICogaG93ZXZlciBkZWNyZW1lbnRpbmcgaXMgZG9uZSBmcm9tIHRoZSBjbGVhbnVwIHBy b2NlZHVyZSwgZGVsZWdhdGVkIHRvDQorICogdGhlIENQVSB0aGF0IGlzIGV4aXRpbmcgaXNvbGF0 aW9uLCBub3QgZnJvbSB0aGUgQ1BVIHRoYXQgY2F1c2VkIGlzb2xhdGlvbg0KKyAqIGJyZWFraW5n Lg0KKyAqDQorICogSWYgaW5jcmVtZW50aW5nIHRoaXMgY291bnRlciB3aGlsZSBzdGFydGluZyBp c29sYXRpb24gZXhpdCBwcm9jZWR1cmUNCisgKiByZXN1bHRzIGluIGEgdmFsdWUgZ3JlYXRlciB0 aGFuIDAsIGlzb2xhdGlvbiBleGl0aW5nIGlzIGFscmVhZHkgaW4NCisgKiBwcm9ncmVzcywgYW5k IGNsZWFudXAgZGlkIG5vdCBzdGFydCB5ZXQuIFRoaXMgbWVhbnMsIGNvdW50ZXIgc2hvdWxkIGJl DQorICogZGVjcmVtZW50ZWQgYmFjaywgYW5kIGlzb2xhdGlvbiBleGl0IHRoYXQgaXMgYWxyZWFk eSBpbiBwcm9ncmVzcywgc2hvdWxkDQorICogYmUgYWxsb3dlZCB0byBjb21wbGV0ZS4gT3RoZXJ3 aXNlLCBhIG5ldyBpc29sYXRpb24gZXhpdCBwcm9jZWR1cmUgc2hvdWxkDQorICogYmUgc3RhcnRl ZC4NCisgKi8NCitERUZJTkVfUEVSX0NQVShhdG9taWNfdCwgaXNvbF9leGl0X2NvdW50ZXIpOw0K Kw0KKy8qDQorICogRGVzY3JpcHRvciBmb3IgaXNvbGF0aW9uLWJyZWFraW5nIFNNUCBjYWxscw0K KyAqLw0KK0RFRklORV9QRVJfQ1BVKGNhbGxfc2luZ2xlX2RhdGFfdCwgaXNvbF9icmVha19jc2Qp Ow0KKw0KK2NwdW1hc2tfdmFyX3QgdGFza19pc29sYXRpb25fbWFwOw0KK2NwdW1hc2tfdmFyX3Qg dGFza19pc29sYXRpb25fY2xlYW51cF9tYXA7DQorc3RhdGljIERFRklORV9TUElOTE9DSyh0YXNr X2lzb2xhdGlvbl9jbGVhbnVwX2xvY2spOw0KKw0KKy8qIFdlIGNhbiBydW4gb24gY3B1cyB0aGF0 IGFyZSBpc29sYXRlZCBmcm9tIHRoZSBzY2hlZHVsZXIgYW5kIGFyZSBub2h6X2Z1bGwuICovDQor c3RhdGljIGludCBfX2luaXQgdGFza19pc29sYXRpb25faW5pdCh2b2lkKQ0KK3sNCisJYWxsb2Nf Ym9vdG1lbV9jcHVtYXNrX3ZhcigmdGFza19pc29sYXRpb25fY2xlYW51cF9tYXApOw0KKwlpZiAo YWxsb2NfY3B1bWFza192YXIoJnRhc2tfaXNvbGF0aW9uX21hcCwgR0ZQX0tFUk5FTCkpDQorCQkv Kg0KKwkJICogQXQgdGhpcyBwb2ludCB0YXNrIGlzb2xhdGlvbiBzaG91bGQgbWF0Y2gNCisJCSAq IG5vaHpfZnVsbC4gVGhpcyBtYXkgY2hhbmdlIGluIHRoZSBmdXR1cmUuDQorCQkgKi8NCisJCWNw dW1hc2tfY29weSh0YXNrX2lzb2xhdGlvbl9tYXAsIHRpY2tfbm9oel9mdWxsX21hc2spOw0KKwly ZXR1cm4gMDsNCit9DQorY29yZV9pbml0Y2FsbCh0YXNrX2lzb2xhdGlvbl9pbml0KQ0KKw0KKy8q IEVuYWJsZSBzdGFjayBiYWNrdHJhY2VzIG9mIGFueSBpbnRlcnJ1cHRzIG9mIHRhc2tfaXNvbGF0 aW9uIGNvcmVzLiAqLw0KK3N0YXRpYyBib29sIHRhc2tfaXNvbGF0aW9uX2RlYnVnOw0KK3N0YXRp YyBpbnQgX19pbml0IHRhc2tfaXNvbGF0aW9uX2RlYnVnX2Z1bmMoY2hhciAqc3RyKQ0KK3sNCisJ dGFza19pc29sYXRpb25fZGVidWcgPSB0cnVlOw0KKwlyZXR1cm4gMTsNCit9DQorX19zZXR1cCgi dGFza19pc29sYXRpb25fZGVidWciLCB0YXNrX2lzb2xhdGlvbl9kZWJ1Z19mdW5jKTsNCisNCisv Kg0KKyAqIFJlY29yZCBuYW1lLCBwaWQgYW5kIGdyb3VwIHBpZCBvZiB0aGUgdGFzayBlbnRlcmlu ZyBpc29sYXRpb24gb24NCisgKiB0aGUgY3VycmVudCBDUFUuDQorICovDQorc3RhdGljIHZvaWQg cmVjb3JkX2N1cnJfaXNvbGF0ZWRfdGFzayh2b2lkKQ0KK3sNCisJaW50IGluZDsNCisJaW50IGNw dSA9IHNtcF9wcm9jZXNzb3JfaWQoKTsNCisJc3RydWN0IGlzb2xfdGFza19kZXNjICpkZXNjID0g JnBlcl9jcHUoaXNvbF90YXNrX2Rlc2NzLCBjcHUpOw0KKwlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRh c2sgPSBjdXJyZW50Ow0KKw0KKwkvKiBGaW5pc2ggZXZlcnl0aGluZyBiZWZvcmUgcmVjb3JkaW5n IGN1cnJlbnQgdGFzayAqLw0KKwlzbXBfbWIoKTsNCisJaW5kID0gYXRvbWljX2luY19yZXR1cm4o JmRlc2MtPmN1cnJfaW5kZXhfd3IpICYgMTsNCisJZGVzYy0+Y29tbVtpbmRdW3NpemVvZih0YXNr LT5jb21tKSAtIDFdID0gJ1wwJzsNCisJbWVtY3B5KGRlc2MtPmNvbW1baW5kXSwgdGFzay0+Y29t bSwgc2l6ZW9mKHRhc2stPmNvbW0pIC0gMSk7DQorCWRlc2MtPnBpZFtpbmRdID0gdGFzay0+cGlk Ow0KKwlkZXNjLT50Z2lkW2luZF0gPSB0YXNrLT50Z2lkOw0KKwlkZXNjLT53YXJuZWRbaW5kXSA9 IGZhbHNlOw0KKwkvKiBXcml0ZSBldmVyeXRoaW5nLCB0byBiZSBzZWVuIGJ5IG90aGVyIENQVXMg Ki8NCisJc21wX21iKCk7DQorCWF0b21pY19pbmMoJmRlc2MtPmN1cnJfaW5kZXgpOw0KKwkvKiBF dmVyeW9uZSB3aWxsIHNlZSB0aGUgbmV3IHJlY29yZCBmcm9tIHRoaXMgcG9pbnQgKi8NCisJc21w X21iKCk7DQorfQ0KKw0KKy8qDQorICogUHJpbnQgbWVzc2FnZSBwcmVmaXhlZCB3aXRoIHRoZSBk ZXNjcmlwdGlvbiBvZiB0aGUgY3VycmVudCAob3INCisgKiBsYXN0KSBpc29sYXRlZCB0YXNrIG9u IGEgZ2l2ZW4gQ1BVLiBJbnRlbmRlZCBmb3IgaXNvbGF0aW9uIGJyZWFraW5nDQorICogbWVzc2Fn ZXMgdGhhdCBpbmNsdWRlIHRhcmdldCB0YXNrIGZvciB0aGUgdXNlcidzIGNvbnZlbmllbmNlLg0K KyAqDQorICogTWVzc2FnZXMgcHJvZHVjZWQgd2l0aCB0aGlzIGZ1bmN0aW9uIG1heSBoYXZlIG9i c29sZXRlIHRhc2sNCisgKiBpbmZvcm1hdGlvbiBpZiBpc29sYXRlZCB0YXNrcyBtYW5hZ2VkIHRv IGV4aXQsIHN0YXJ0IGFuZCBlbnRlcg0KKyAqIGlzb2xhdGlvbiBtdWx0aXBsZSB0aW1lcywgb3Ig bXVsdGlwbGUgdGFza3MgdHJpZWQgdG8gZW50ZXINCisgKiBpc29sYXRpb24gb24gdGhlIHNhbWUg Q1BVIGF0IG9uY2UuIEZvciB0aG9zZSB1bnVzdWFsIGNhc2VzIGl0IHdvdWxkDQorICogY29udGFp biBhIHZhbGlkIGRlc2NyaXB0aW9uIG9mIHRoZSBjYXVzZSBmb3IgaXNvbGF0aW9uIGJyZWFraW5n IGFuZA0KKyAqIHRhcmdldCBDUFUgbnVtYmVyLCBqdXN0IG5vdCB0aGUgY29ycmVjdCBkZXNjcmlw dGlvbiBvZiB3aGljaCB0YXNrDQorICogZW5kZWQgdXAgbG9zaW5nIGlzb2xhdGlvbi4NCisgKi8N CitpbnQgdGFza19pc29sYXRpb25fbWVzc2FnZShpbnQgY3B1LCBpbnQgbGV2ZWwsIGJvb2wgc3Vw cCwgY29uc3QgY2hhciAqZm10LCAuLi4pDQorew0KKwlzdHJ1Y3QgaXNvbF90YXNrX2Rlc2MgKmRl c2M7DQorCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzazsNCisJdmFfbGlzdCBhcmdzOw0KKwljaGFy IGJ1Zl9wcmVmaXhbVEFTS19DT01NX0xFTiArIDIwICsgMyAqIDIwXTsNCisJY2hhciBidWZbMjAw XTsNCisJaW50IGN1cnJfY3B1LCBpbmRfY291bnRlciwgaW5kX2NvdW50ZXJfb2xkLCBpbmQ7DQor DQorCWN1cnJfY3B1ID0gZ2V0X2NwdSgpOw0KKwlkZXNjID0gJnBlcl9jcHUoaXNvbF90YXNrX2Rl c2NzLCBjcHUpOw0KKwlpbmRfY291bnRlciA9IGF0b21pY19yZWFkKCZkZXNjLT5jdXJyX2luZGV4 KTsNCisNCisJaWYgKGN1cnJfY3B1ID09IGNwdSkgew0KKwkJLyoNCisJCSAqIE1lc3NhZ2UgaXMg Zm9yIHRoZSBjdXJyZW50IENQVSBzbyBjdXJyZW50DQorCQkgKiB0YXNrX3N0cnVjdCBzaG91bGQg YmUgdXNlZCBpbnN0ZWFkIG9mIGNhY2hlZA0KKwkJICogaW5mb3JtYXRpb24uDQorCQkgKg0KKwkJ ICogTGlrZSBpbiBvdGhlciBkaWFnbm9zdGljIG1lc3NhZ2VzLCBpZiBpc3N1ZWQgZnJvbQ0KKwkJ ICogaW50ZXJydXB0IGNvbnRleHQsIGN1cnJlbnQgd2lsbCBiZSB0aGUgaW50ZXJydXB0ZWQNCisJ CSAqIHRhc2suIFVubGlrZSBvdGhlciBkaWFnbm9zdGljIG1lc3NhZ2VzLCB0aGlzIGlzDQorCQkg KiBhbHdheXMgcmVsZXZhbnQgYmVjYXVzZSB0aGUgbWVzc2FnZSBpcyBhYm91dA0KKwkJICogaW50 ZXJydXB0aW5nIGEgdGFzay4NCisJCSAqLw0KKwkJaW5kID0gaW5kX2NvdW50ZXIgJiAxOw0KKwkJ aWYgKHN1cHAgJiYgZGVzYy0+d2FybmVkW2luZF0pIHsNCisJCQkvKg0KKwkJCSAqIElmIHN1cHAg aXMgdHJ1ZSwgc2tpcCB0aGUgbWVzc2FnZSBpZiB0aGUNCisJCQkgKiBzYW1lIHRhc2sgd2FzIG1l bnRpb25lZCBpbiB0aGUgbWVzc2FnZQ0KKwkJCSAqIG9yaWdpbmF0ZWQgb24gcmVtb3RlIENQVSwg YW5kIGl0IGRpZCBub3QNCisJCQkgKiByZS1lbnRlciBpc29sYXRlZCBzdGF0ZSBzaW5jZSB0aGVu ICh3YXJuZWQNCisJCQkgKiBpcyB0cnVlKS4gT25seSBsb2NhbCBtZXNzYWdlcyBmb2xsb3dpbmcN CisJCQkgKiByZW1vdGUgbWVzc2FnZXMsIGxpa2VseSBhYm91dCB0aGUgc2FtZQ0KKwkJCSAqIGlz b2xhdGlvbiBicmVha2luZyBldmVudCwgYXJlIHNraXBwZWQgdG8NCisJCQkgKiBhdm9pZCBkdXBs aWNhdGlvbi4gSWYgcmVtb3RlIGNhdXNlIGlzDQorCQkJICogaW1tZWRpYXRlbHkgZm9sbG93ZWQg YnkgYSBsb2NhbCBvbmUgYmVmb3JlDQorCQkJICogaXNvbGF0aW9uIGlzIGJyb2tlbiwgbG9jYWwg Y2F1c2UgaXMgc2tpcHBlZA0KKwkJCSAqIGZyb20gbWVzc2FnZXMuDQorCQkJICovDQorCQkJcHV0 X2NwdSgpOw0KKwkJCXJldHVybiAwOw0KKwkJfQ0KKwkJdGFzayA9IGN1cnJlbnQ7DQorCQlzbnBy aW50ZihidWZfcHJlZml4LCBzaXplb2YoYnVmX3ByZWZpeCksDQorCQkJICJpc29sYXRpb24gJXMv JWQvJWQgKGNwdSAlZCkiLA0KKwkJCSB0YXNrLT5jb21tLCB0YXNrLT50Z2lkLCB0YXNrLT5waWQs IGNwdSk7DQorCQlwdXRfY3B1KCk7DQorCX0gZWxzZSB7DQorCQkvKg0KKwkJICogTWVzc2FnZSBp cyBmb3IgcmVtb3RlIENQVSwgdXNlIGNhY2hlZCBpbmZvcm1hdGlvbi4NCisJCSAqLw0KKwkJcHV0 X2NwdSgpOw0KKwkJLyoNCisJCSAqIE1ha2Ugc3VyZSwgaW5kZXggcmVtYWluZWQgdW5jaGFuZ2Vk IHdoaWxlIGRhdGEgd2FzDQorCQkgKiBjb3BpZWQuIElmIGl0IGNoYW5nZWQsIGRhdGEgdGhhdCB3 YXMgY29waWVkIG1heSBiZQ0KKwkJICogaW5jb25zaXN0ZW50IGJlY2F1c2UgdHdvIHVwZGF0ZXMg aW4gYSBzZXF1ZW5jZSBjb3VsZA0KKwkJICogb3ZlcndyaXRlIHRoZSBkYXRhIHdoaWxlIGl0IHdh cyBiZWluZyByZWFkLg0KKwkJICovDQorCQlkbyB7DQorCQkJLyogTWFrZSBzdXJlIHdlIGFyZSBy ZWFkaW5nIHVwIHRvIGRhdGUgdmFsdWVzICovDQorCQkJc21wX21iKCk7DQorCQkJaW5kID0gaW5k X2NvdW50ZXIgJiAxOw0KKwkJCXNucHJpbnRmKGJ1Zl9wcmVmaXgsIHNpemVvZihidWZfcHJlZml4 KSwNCisJCQkJICJpc29sYXRpb24gJXMvJWQvJWQgKGNwdSAlZCkiLA0KKwkJCQkgZGVzYy0+Y29t bVtpbmRdLCBkZXNjLT50Z2lkW2luZF0sDQorCQkJCSBkZXNjLT5waWRbaW5kXSwgY3B1KTsNCisJ CQlkZXNjLT53YXJuZWRbaW5kXSA9IHRydWU7DQorCQkJaW5kX2NvdW50ZXJfb2xkID0gaW5kX2Nv dW50ZXI7DQorCQkJLyogUmVjb3JkIHRoZSB3YXJuZWQgZmxhZywgdGhlbiByZS1yZWFkIGRlc2Ny aXB0b3IgKi8NCisJCQlzbXBfbWIoKTsNCisJCQlpbmRfY291bnRlciA9IGF0b21pY19yZWFkKCZk ZXNjLT5jdXJyX2luZGV4KTsNCisJCQkvKg0KKwkJCSAqIElmIHRoZSBjb3VudGVyIGNoYW5nZWQs IHNvbWV0aGluZyB3YXMgdXBkYXRlZCwgc28NCisJCQkgKiByZXBlYXQgZXZlcnl0aGluZyB0byBn ZXQgdGhlIGN1cnJlbnQgZGF0YQ0KKwkJCSAqLw0KKwkJfSB3aGlsZSAoaW5kX2NvdW50ZXIgIT0g aW5kX2NvdW50ZXJfb2xkKTsNCisJfQ0KKw0KKwl2YV9zdGFydChhcmdzLCBmbXQpOw0KKwl2c25w cmludGYoYnVmLCBzaXplb2YoYnVmKSwgZm10LCBhcmdzKTsNCisJdmFfZW5kKGFyZ3MpOw0KKw0K Kwlzd2l0Y2ggKGxldmVsKSB7DQorCWNhc2UgTE9HTEVWRUxfRU1FUkc6DQorCQlwcl9lbWVyZygi JXM6ICVzIiwgYnVmX3ByZWZpeCwgYnVmKTsNCisJCWJyZWFrOw0KKwljYXNlIExPR0xFVkVMX0FM RVJUOg0KKwkJcHJfYWxlcnQoIiVzOiAlcyIsIGJ1Zl9wcmVmaXgsIGJ1Zik7DQorCQlicmVhazsN CisJY2FzZSBMT0dMRVZFTF9DUklUOg0KKwkJcHJfY3JpdCgiJXM6ICVzIiwgYnVmX3ByZWZpeCwg YnVmKTsNCisJCWJyZWFrOw0KKwljYXNlIExPR0xFVkVMX0VSUjoNCisJCXByX2VycigiJXM6ICVz IiwgYnVmX3ByZWZpeCwgYnVmKTsNCisJCWJyZWFrOw0KKwljYXNlIExPR0xFVkVMX1dBUk5JTkc6 DQorCQlwcl93YXJuKCIlczogJXMiLCBidWZfcHJlZml4LCBidWYpOw0KKwkJYnJlYWs7DQorCWNh c2UgTE9HTEVWRUxfTk9USUNFOg0KKwkJcHJfbm90aWNlKCIlczogJXMiLCBidWZfcHJlZml4LCBi dWYpOw0KKwkJYnJlYWs7DQorCWNhc2UgTE9HTEVWRUxfSU5GTzoNCisJCXByX2luZm8oIiVzOiAl cyIsIGJ1Zl9wcmVmaXgsIGJ1Zik7DQorCQlicmVhazsNCisJY2FzZSBMT0dMRVZFTF9ERUJVRzoN CisJCXByX2RlYnVnKCIlczogJXMiLCBidWZfcHJlZml4LCBidWYpOw0KKwkJYnJlYWs7DQorCWRl ZmF1bHQ6DQorCQkvKiBObyBtZXNzYWdlIHdpdGhvdXQgYSB2YWxpZCBsZXZlbCAqLw0KKwkJcmV0 dXJuIDA7DQorCX0NCisJcmV0dXJuIDE7DQorfQ0KKw0KKy8qDQorICogRHVtcCBzdGFjayBpZiBu ZWVkIGJlLiBUaGlzIGNhbiBiZSBoZWxwZnVsIGV2ZW4gZnJvbSB0aGUgZmluYWwgZXhpdA0KKyAq IHRvIHVzZXJtb2RlIGNvZGUgc2luY2Ugc3RhY2sgdHJhY2VzIHNvbWV0aW1lcyBjYXJyeSBpbmZv cm1hdGlvbiBhYm91dA0KKyAqIHdoYXQgcHV0IHlvdSBpbnRvIHRoZSBrZXJuZWwsIGUuZy4gYW4g aW50ZXJydXB0IG51bWJlciBlbmNvZGVkIGluDQorICogdGhlIGluaXRpYWwgZW50cnkgc3RhY2sg ZnJhbWUgdGhhdCBpcyBzdGlsbCB2aXNpYmxlIGF0IGV4aXQgdGltZS4NCisgKi8NCitzdGF0aWMg dm9pZCBkZWJ1Z19kdW1wX3N0YWNrKHZvaWQpDQorew0KKwlpZiAodGFza19pc29sYXRpb25fZGVi dWcpDQorCQlkdW1wX3N0YWNrKCk7DQorfQ0KKw0KKy8qDQorICogU2V0IHRoZSBmbGFncyB3b3Jk IGJ1dCBkb24ndCB0cnkgdG8gYWN0dWFsbHkgc3RhcnQgdGFzayBpc29sYXRpb24geWV0Lg0KKyAq IFdlIHdpbGwgc3RhcnQgaXQgd2hlbiBlbnRlcmluZyB1c2VyIHNwYWNlIGluIHRhc2tfaXNvbGF0 aW9uX3N0YXJ0KCkuDQorICovDQoraW50IHRhc2tfaXNvbGF0aW9uX3JlcXVlc3QodW5zaWduZWQg aW50IGZsYWdzKQ0KK3sNCisJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrID0gY3VycmVudDsNCisN CisJLyoNCisJICogVGhlIHRhc2sgaXNvbGF0aW9uIGZsYWdzIHNob3VsZCBhbHdheXMgYmUgY2xl YXJlZCBqdXN0IGJ5DQorCSAqIHZpcnR1ZSBvZiBoYXZpbmcgZW50ZXJlZCB0aGUga2VybmVsLg0K KwkgKi8NCisJV0FSTl9PTl9PTkNFKHRlc3RfdHNrX3RocmVhZF9mbGFnKHRhc2ssIFRJRl9UQVNL X0lTT0xBVElPTikpOw0KKwlXQVJOX09OX09OQ0UodGFzay0+dGFza19pc29sYXRpb25fZmxhZ3Mg IT0gMCk7DQorCVdBUk5fT05fT05DRSh0YXNrLT50YXNrX2lzb2xhdGlvbl9zdGF0ZSAhPSBTVEFU RV9OT1JNQUwpOw0KKw0KKwl0YXNrLT50YXNrX2lzb2xhdGlvbl9mbGFncyA9IGZsYWdzOw0KKwlp ZiAoISh0YXNrLT50YXNrX2lzb2xhdGlvbl9mbGFncyAmIFBSX1RBU0tfSVNPTEFUSU9OX0VOQUJM RSkpDQorCQlyZXR1cm4gMDsNCisNCisJLyogV2UgYXJlIHRyeWluZyB0byBlbmFibGUgdGFzayBp c29sYXRpb24uICovDQorCXNldF90c2tfdGhyZWFkX2ZsYWcodGFzaywgVElGX1RBU0tfSVNPTEFU SU9OKTsNCisNCisJLyoNCisJICogU2h1dCBkb3duIHRoZSB2bXN0YXQgd29ya2VyIHNvIHdlJ3Jl IG5vdCBpbnRlcnJ1cHRlZCBsYXRlci4NCisJICogV2UgaGF2ZSB0byB0cnkgdG8gZG8gdGhpcyBo ZXJlICh3aXRoIGludGVycnVwdHMgZW5hYmxlZCkgc2luY2UNCisJICogd2UgYXJlIGNhbmNlbGlu ZyBkZWxheWVkIHdvcmsgYW5kIHdpbGwgY2FsbCBmbHVzaF93b3JrKCkNCisJICogKHdoaWNoIGVu YWJsZXMgaW50ZXJydXB0cykgYW5kIHBvc3NpYmx5IHNjaGVkdWxlKCkuDQorCSAqLw0KKwlxdWll dF92bXN0YXRfc3luYygpOw0KKw0KKwkvKiBXZSByZXR1cm4gMCBoZXJlIGJ1dCB3ZSBtYXkgY2hh bmdlIHRoYXQgaW4gdGFza19pc29sYXRpb25fc3RhcnQoKS4gKi8NCisJcmV0dXJuIDA7DQorfQ0K Kw0KKy8qDQorICogUGVyZm9ybSBhY3Rpb25zIHRoYXQgc2hvdWxkIGJlIGRvbmUgaW1tZWRpYXRl bHkgb24gZXhpdCBmcm9tIGlzb2xhdGlvbi4NCisgKi8NCitzdGF0aWMgdm9pZCBmYXN0X3Rhc2tf aXNvbGF0aW9uX2NwdV9jbGVhbnVwKHZvaWQgKmluZm8pDQorew0KKwlhdG9taWNfZGVjKCZwZXJf Y3B1KGlzb2xfZXhpdF9jb3VudGVyLCBzbXBfcHJvY2Vzc29yX2lkKCkpKTsNCisJLyogQXQgdGhp cyBwb2ludCBicmVha2luZyBpc29sYXRpb24gZnJvbSBvdGhlciBDUFVzIGlzIHBvc3NpYmxlIGFn YWluICovDQorDQorCS8qDQorCSAqIFRoaXMgdGFzayBpcyBubyBsb25nZXIgaXNvbGF0ZWQgKGFu ZCBpZiBieSBhbnkgY2hhbmNlIHRoaXMNCisJICogaXMgdGhlIHdyb25nIHRhc2ssIGl0J3MgYWxy ZWFkeSBub3QgaXNvbGF0ZWQpDQorCSAqLw0KKwljdXJyZW50LT50YXNrX2lzb2xhdGlvbl9mbGFn cyA9IDA7DQorCWNsZWFyX3Rza190aHJlYWRfZmxhZyhjdXJyZW50LCBUSUZfVEFTS19JU09MQVRJ T04pOw0KKw0KKwkvKiBSdW4gdGhlIHJlc3Qgb2YgY2xlYW51cCBsYXRlciAqLw0KKwlzZXRfdHNr X3RocmVhZF9mbGFnKGN1cnJlbnQsIFRJRl9OT1RJRllfUkVTVU1FKTsNCisNCisJLyogQ29weSBm bGFncyB3aXRoIHRhc2sgaXNvbGF0aW9uIGRpc2FibGVkICovDQorCXRoaXNfY3B1X3dyaXRlKHRz a190aHJlYWRfZmxhZ3NfY2FjaGUsDQorCQkgICAgICAgUkVBRF9PTkNFKHRhc2tfdGhyZWFkX2lu Zm8oY3VycmVudCktPmZsYWdzKSk7DQorfQ0KKw0KKy8qIERpc2FibGUgdGFzayBpc29sYXRpb24g Zm9yIHRoZSBzcGVjaWZpZWQgdGFzay4gKi8NCitzdGF0aWMgdm9pZCBzdG9wX2lzb2xhdGlvbihz dHJ1Y3QgdGFza19zdHJ1Y3QgKnApDQorew0KKwlpbnQgY3B1LCB0aGlzX2NwdTsNCisJdW5zaWdu ZWQgbG9uZyBmbGFnczsNCisNCisJdGhpc19jcHUgPSBnZXRfY3B1KCk7DQorCWNwdSA9IHRhc2tf Y3B1KHApOw0KKwlpZiAoYXRvbWljX2luY19yZXR1cm4oJnBlcl9jcHUoaXNvbF9leGl0X2NvdW50 ZXIsIGNwdSkpID4gMSkgew0KKwkJLyogQWxyZWFkeSBleGl0aW5nIGlzb2xhdGlvbiAqLw0KKwkJ YXRvbWljX2RlYygmcGVyX2NwdShpc29sX2V4aXRfY291bnRlciwgY3B1KSk7DQorCQlwdXRfY3B1 KCk7DQorCQlyZXR1cm47DQorCX0NCisNCisJaWYgKHAgPT0gY3VycmVudCkgew0KKwkJcC0+dGFz a19pc29sYXRpb25fc3RhdGUgPSBTVEFURV9OT1JNQUw7DQorCQlmYXN0X3Rhc2tfaXNvbGF0aW9u X2NwdV9jbGVhbnVwKE5VTEwpOw0KKwkJdGFza19pc29sYXRpb25fY3B1X2NsZWFudXAoKTsNCisJ CWlmIChhdG9taWNfZGVjX3JldHVybigmcGVyX2NwdShpc29sX2NvdW50ZXIsIGNwdSkpIDwgMCkg ew0KKwkJCS8qIElzIG5vdCBpc29sYXRlZCBhbHJlYWR5ICovDQorCQkJYXRvbWljX2luYygmcGVy X2NwdShpc29sX2NvdW50ZXIsIGNwdSkpOw0KKwkJfQ0KKwkJcHV0X2NwdSgpOw0KKwl9IGVsc2Ug ew0KKwkJaWYgKGF0b21pY19kZWNfcmV0dXJuKCZwZXJfY3B1KGlzb2xfY291bnRlciwgY3B1KSkg PCAwKSB7DQorCQkJLyogSXMgbm90IGlzb2xhdGVkIGFscmVhZHkgKi8NCisJCQlhdG9taWNfaW5j KCZwZXJfY3B1KGlzb2xfY291bnRlciwgY3B1KSk7DQorCQkJYXRvbWljX2RlYygmcGVyX2NwdShp c29sX2V4aXRfY291bnRlciwgY3B1KSk7DQorCQkJcHV0X2NwdSgpOw0KKwkJCXJldHVybjsNCisJ CX0NCisJCS8qDQorCQkgKiBTY2hlZHVsZSAic2xvdyIgY2xlYW51cC4gVGhpcyByZWxpZXMgb24N CisJCSAqIFRJRl9OT1RJRllfUkVTVU1FIGJlaW5nIHNldA0KKwkJICovDQorCQlzcGluX2xvY2tf aXJxc2F2ZSgmdGFza19pc29sYXRpb25fY2xlYW51cF9sb2NrLCBmbGFncyk7DQorCQljcHVtYXNr X3NldF9jcHUoY3B1LCB0YXNrX2lzb2xhdGlvbl9jbGVhbnVwX21hcCk7DQorCQlzcGluX3VubG9j a19pcnFyZXN0b3JlKCZ0YXNrX2lzb2xhdGlvbl9jbGVhbnVwX2xvY2ssIGZsYWdzKTsNCisJCS8q DQorCQkgKiBTZXR0aW5nIGZsYWdzIGlzIGRlbGVnYXRlZCB0byB0aGUgQ1BVIHdoZXJlDQorCQkg KiBpc29sYXRlZCB0YXNrIGlzIHJ1bm5pbmcNCisJCSAqIGlzb2xfZXhpdF9jb3VudGVyIHdpbGwg YmUgZGVjcmVtZW50ZWQgZnJvbSB0aGVyZSBhcyB3ZWxsLg0KKwkJICovDQorCQlwZXJfY3B1KGlz b2xfYnJlYWtfY3NkLCBjcHUpLmZ1bmMgPQ0KKwkJICAgIGZhc3RfdGFza19pc29sYXRpb25fY3B1 X2NsZWFudXA7DQorCQlwZXJfY3B1KGlzb2xfYnJlYWtfY3NkLCBjcHUpLmluZm8gPSBOVUxMOw0K KwkJcGVyX2NwdShpc29sX2JyZWFrX2NzZCwgY3B1KS5mbGFncyA9IDA7DQorCQlzbXBfY2FsbF9m dW5jdGlvbl9zaW5nbGVfYXN5bmMoY3B1LA0KKwkJCQkJICAgICAgICZwZXJfY3B1KGlzb2xfYnJl YWtfY3NkLCBjcHUpKTsNCisJCXB1dF9jcHUoKTsNCisJfQ0KK30NCisNCisvKg0KKyAqIFRoaXMg Y29kZSBydW5zIHdpdGggaW50ZXJydXB0cyBkaXNhYmxlZCBqdXN0IGJlZm9yZSB0aGUgcmV0dXJu IHRvDQorICogdXNlcnNwYWNlLCBhZnRlciBhIHByY3RsKCkgaGFzIHJlcXVlc3RlZCBlbmFibGlu ZyB0YXNrIGlzb2xhdGlvbi4NCisgKiBXZSB0YWtlIHdoYXRldmVyIHN0ZXBzIGFyZSBuZWVkZWQg dG8gYXZvaWQgYmVpbmcgaW50ZXJydXB0ZWQgbGF0ZXI6DQorICogZHJhaW4gdGhlIGxydSBwYWdl cywgc3RvcCB0aGUgc2NoZWR1bGVyIHRpY2ssIGV0Yy4gIE1vcmUNCisgKiBmdW5jdGlvbmFsaXR5 IG1heSBiZSBhZGRlZCBoZXJlIGxhdGVyIHRvIGF2b2lkIG90aGVyIHR5cGVzIG9mDQorICogaW50 ZXJydXB0cyBmcm9tIG90aGVyIGtlcm5lbCBzdWJzeXN0ZW1zLg0KKyAqDQorICogSWYgd2UgY2Fu J3QgZW5hYmxlIHRhc2sgaXNvbGF0aW9uLCB3ZSB1cGRhdGUgdGhlIHN5c2NhbGwgcmV0dXJuDQor ICogdmFsdWUgd2l0aCBhbiBhcHByb3ByaWF0ZSBlcnJvci4NCisgKi8NCit2b2lkIHRhc2tfaXNv bGF0aW9uX3N0YXJ0KHZvaWQpDQorew0KKwlpbnQgZXJyb3I7DQorDQorCS8qDQorCSAqIFdlIHNo b3VsZCBvbmx5IGJlIGNhbGxlZCBpbiBTVEFURV9OT1JNQUwgKGlzb2xhdGlvbiBkaXNhYmxlZCks DQorCSAqIG9uIG91ciB3YXkgb3V0IG9mIHRoZSBrZXJuZWwgZnJvbSB0aGUgcHJjdGwoKSB0aGF0 IHR1cm5lZCBpdCBvbi4NCisJICogSWYgd2UgYXJlIGV4aXRpbmcgZnJvbSB0aGUga2VybmVsIGlu IGFub3RoZXIgc3RhdGUsIGl0IG1lYW5zIHdlDQorCSAqIG1hZGUgaXQgYmFjayBpbnRvIHRoZSBr ZXJuZWwgd2l0aG91dCBkaXNhYmxpbmcgdGFzayBpc29sYXRpb24sDQorCSAqIGFuZCB3ZSBzaG91 bGQgaW52ZXN0aWdhdGUgaG93IChhbmQgaW4gYW55IGNhc2UgZGlzYWJsZSB0YXNrDQorCSAqIGlz b2xhdGlvbiBhdCB0aGlzIHBvaW50KS4gIFdlIGFyZSBjbGVhcmx5IG5vdCBvbiB0aGUgcGF0aCBi YWNrDQorCSAqIGZyb20gdGhlIHByY3RsKCkgc28gd2UgZG9uJ3QgdG91Y2ggdGhlIHN5c2NhbGwg cmV0dXJuIHZhbHVlLg0KKwkgKi8NCisJaWYgKFdBUk5fT05fT05DRShjdXJyZW50LT50YXNrX2lz b2xhdGlvbl9zdGF0ZSAhPSBTVEFURV9OT1JNQUwpKSB7DQorCQkvKiBJbmNyZW1lbnQgY291bnRl ciwgdGhpcyB3aWxsIGFsbG93IGlzb2xhdGlvbiBicmVha2luZyAqLw0KKwkJaWYgKGF0b21pY19p bmNfcmV0dXJuKCZwZXJfY3B1KGlzb2xfY291bnRlciwNCisJCQkJCSAgICAgIHNtcF9wcm9jZXNz b3JfaWQoKSkpID4gMSkgew0KKwkJCWF0b21pY19kZWMoJnBlcl9jcHUoaXNvbF9jb3VudGVyLCBz bXBfcHJvY2Vzc29yX2lkKCkpKTsNCisJCX0NCisJCWF0b21pY19pbmMoJnBlcl9jcHUoaXNvbF9j b3VudGVyLCBzbXBfcHJvY2Vzc29yX2lkKCkpKTsNCisJCXN0b3BfaXNvbGF0aW9uKGN1cnJlbnQp Ow0KKwkJcmV0dXJuOw0KKwl9DQorDQorCS8qDQorCSAqIE11c3QgYmUgYWZmaW5pdGl6ZWQgdG8g YSBzaW5nbGUgY29yZSB3aXRoIHRhc2sgaXNvbGF0aW9uIHBvc3NpYmxlLg0KKwkgKiBJbiBwcmlu Y2lwbGUgdGhpcyBjb3VsZCBiZSByZW1vdGVseSBtb2RpZmllZCBiZXR3ZWVuIHRoZSBwcmN0bCgp DQorCSAqIGFuZCB0aGUgcmV0dXJuIHRvIHVzZXJzcGFjZSwgc28gd2UgaGF2ZSB0byBjaGVjayBp dCBoZXJlLg0KKwkgKi8NCisJaWYgKGN1cnJlbnQtPm5yX2NwdXNfYWxsb3dlZCAhPSAxIHx8DQor CSAgICAhaXNfaXNvbGF0aW9uX2NwdShzbXBfcHJvY2Vzc29yX2lkKCkpKSB7DQorCQllcnJvciA9 IC1FSU5WQUw7DQorCQlnb3RvIGVycm9yOw0KKwl9DQorDQorCS8qIElmIHRoZSB2bXN0YXQgZGVs YXllZCB3b3JrIGlzIG5vdCBjYW5jZWxlZCwgd2UgaGF2ZSB0byB0cnkgYWdhaW4uICovDQorCWlm ICghdm1zdGF0X2lkbGUoKSkgew0KKwkJZXJyb3IgPSAtRUFHQUlOOw0KKwkJZ290byBlcnJvcjsN CisJfQ0KKw0KKwkvKiBUcnkgdG8gc3RvcCB0aGUgZHluYW1pYyB0aWNrLiAqLw0KKwllcnJvciA9 IHRyeV9zdG9wX2Z1bGxfdGljaygpOw0KKwlpZiAoZXJyb3IpDQorCQlnb3RvIGVycm9yOw0KKw0K KwkvKiBEcmFpbiB0aGUgcGFnZXZlY3MgdG8gYXZvaWQgdW5uZWNlc3NhcnkgSVBJIGZsdXNoZXMg bGF0ZXIuICovDQorCWxydV9hZGRfZHJhaW4oKTsNCisNCisJLyogSW5jcmVtZW50IGNvdW50ZXIs IHRoaXMgd2lsbCBhbGxvdyBpc29sYXRpb24gYnJlYWtpbmcgKi8NCisJaWYgKGF0b21pY19pbmNf cmV0dXJuKCZwZXJfY3B1KGlzb2xfY291bnRlciwNCisJCQkJICAgICAgc21wX3Byb2Nlc3Nvcl9p ZCgpKSkgPiAxKSB7DQorCQlhdG9taWNfZGVjKCZwZXJfY3B1KGlzb2xfY291bnRlciwgc21wX3By b2Nlc3Nvcl9pZCgpKSk7DQorCX0NCisNCisJLyogUmVjb3JkIGlzb2xhdGVkIHRhc2sgSURzIGFu ZCBuYW1lICovDQorCXJlY29yZF9jdXJyX2lzb2xhdGVkX3Rhc2soKTsNCisNCisJLyogQ29weSBm bGFncyB3aXRoIHRhc2sgaXNvbGF0aW9uIGVuYWJsZWQgKi8NCisJdGhpc19jcHVfd3JpdGUodHNr X3RocmVhZF9mbGFnc19jYWNoZSwNCisJCSAgICAgICBSRUFEX09OQ0UodGFza190aHJlYWRfaW5m byhjdXJyZW50KS0+ZmxhZ3MpKTsNCisNCisJY3VycmVudC0+dGFza19pc29sYXRpb25fc3RhdGUg PSBTVEFURV9JU09MQVRFRDsNCisJcmV0dXJuOw0KKw0KK2Vycm9yOg0KKwkvKiBJbmNyZW1lbnQg Y291bnRlciwgdGhpcyB3aWxsIGFsbG93IGlzb2xhdGlvbiBicmVha2luZyAqLw0KKwlpZiAoYXRv bWljX2luY19yZXR1cm4oJnBlcl9jcHUoaXNvbF9jb3VudGVyLA0KKwkJCQkgICAgICBzbXBfcHJv Y2Vzc29yX2lkKCkpKSA+IDEpIHsNCisJCWF0b21pY19kZWMoJnBlcl9jcHUoaXNvbF9jb3VudGVy LCBzbXBfcHJvY2Vzc29yX2lkKCkpKTsNCisJfQ0KKwlzdG9wX2lzb2xhdGlvbihjdXJyZW50KTsN CisJc3lzY2FsbF9zZXRfcmV0dXJuX3ZhbHVlKGN1cnJlbnQsIGN1cnJlbnRfcHRfcmVncygpLCBl cnJvciwgMCk7DQorfQ0KKw0KKy8qIFN0b3AgdGFzayBpc29sYXRpb24gb24gdGhlIHJlbW90ZSB0 YXNrIGFuZCBzZW5kIGl0IGEgc2lnbmFsLiAqLw0KK3N0YXRpYyB2b2lkIHNlbmRfaXNvbGF0aW9u X3NpZ25hbChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spDQorew0KKwlpbnQgZmxhZ3MgPSB0YXNr LT50YXNrX2lzb2xhdGlvbl9mbGFnczsNCisJa2VybmVsX3NpZ2luZm9fdCBpbmZvID0gew0KKwkJ LnNpX3NpZ25vID0gUFJfVEFTS19JU09MQVRJT05fR0VUX1NJRyhmbGFncykgPzogU0lHS0lMTCwN CisJfTsNCisNCisJc3RvcF9pc29sYXRpb24odGFzayk7DQorCXNlbmRfc2lnX2luZm8oaW5mby5z aV9zaWdubywgJmluZm8sIHRhc2spOw0KK30NCisNCisvKiBPbmx5IGEgZmV3IHN5c2NhbGxzIGFy ZSB2YWxpZCBvbmNlIHdlIGFyZSBpbiB0YXNrIGlzb2xhdGlvbiBtb2RlLiAqLw0KK3N0YXRpYyBi b29sIGlzX2FjY2VwdGFibGVfc3lzY2FsbChpbnQgc3lzY2FsbCkNCit7DQorCS8qIE5vIG5lZWQg dG8gaW5jdXIgYW4gaXNvbGF0aW9uIHNpZ25hbCBpZiB3ZSBhcmUganVzdCBleGl0aW5nLiAqLw0K KwlpZiAoc3lzY2FsbCA9PSBfX05SX2V4aXQgfHwgc3lzY2FsbCA9PSBfX05SX2V4aXRfZ3JvdXAp DQorCQlyZXR1cm4gdHJ1ZTsNCisNCisJLyogQ2hlY2sgdG8gc2VlIGlmIGl0J3MgdGhlIHByY3Rs IGZvciBpc29sYXRpb24uICovDQorCWlmIChzeXNjYWxsID09IF9fTlJfcHJjdGwpIHsNCisJCXVu c2lnbmVkIGxvbmcgYXJnW1NZU0NBTExfTUFYX0FSR1NdOw0KKw0KKwkJc3lzY2FsbF9nZXRfYXJn dW1lbnRzKGN1cnJlbnQsIGN1cnJlbnRfcHRfcmVncygpLCBhcmcpOw0KKwkJaWYgKGFyZ1swXSA9 PSBQUl9UQVNLX0lTT0xBVElPTikNCisJCQlyZXR1cm4gdHJ1ZTsNCisJfQ0KKw0KKwlyZXR1cm4g ZmFsc2U7DQorfQ0KKw0KKy8qDQorICogVGhpcyByb3V0aW5lIGlzIGNhbGxlZCBmcm9tIHN5c2Nh bGwgZW50cnksIHByZXZlbnRzIG1vc3Qgc3lzY2FsbHMNCisgKiBmcm9tIGV4ZWN1dGluZywgYW5k IGlmIG5lZWRlZCByYWlzZXMgYSBzaWduYWwgdG8gbm90aWZ5IHRoZSBwcm9jZXNzLg0KKyAqDQor ICogTm90ZSB0aGF0IHdlIGhhdmUgdG8gc3RvcCBpc29sYXRpb24gYmVmb3JlIHdlIGV2ZW4gcHJp bnQgYSBtZXNzYWdlDQorICogaGVyZSwgc2luY2Ugb3RoZXJ3aXNlIHdlIG1pZ2h0IGVuZCB1cCBy ZXBvcnRpbmcgYW4gaW50ZXJydXB0IGR1ZSB0bw0KKyAqIGtpY2tpbmcgdGhlIHByaW50ayBoYW5k bGluZyBjb2RlLCByYXRoZXIgdGhhbiByZXBvcnRpbmcgdGhlIHRydWUNCisgKiBjYXVzZSBvZiBp bnRlcnJ1cHQgaGVyZS4NCisgKg0KKyAqIFRoZSBtZXNzYWdlIGlzIG5vdCBzdXBwcmVzc2VkIGJ5 IHByZXZpb3VzIHJlbW90ZWx5IHRyaWdnZXJlZA0KKyAqIG1lc3NhZ2VzLg0KKyAqLw0KK2ludCB0 YXNrX2lzb2xhdGlvbl9zeXNjYWxsKGludCBzeXNjYWxsKQ0KK3sNCisJc3RydWN0IHRhc2tfc3Ry dWN0ICp0YXNrID0gY3VycmVudDsNCisNCisJaWYgKGlzX2FjY2VwdGFibGVfc3lzY2FsbChzeXNj YWxsKSkgew0KKwkJc3RvcF9pc29sYXRpb24odGFzayk7DQorCQlyZXR1cm4gMDsNCisJfQ0KKw0K KwlzZW5kX2lzb2xhdGlvbl9zaWduYWwodGFzayk7DQorDQorCXByX3Rhc2tfaXNvbF93YXJuKHNt cF9wcm9jZXNzb3JfaWQoKSwNCisJCQkgICJ0YXNrX2lzb2xhdGlvbiBsb3N0IGR1ZSB0byBzeXNj YWxsICVkXG4iLA0KKwkJCSAgc3lzY2FsbCk7DQorCWRlYnVnX2R1bXBfc3RhY2soKTsNCisNCisJ c3lzY2FsbF9zZXRfcmV0dXJuX3ZhbHVlKHRhc2ssIGN1cnJlbnRfcHRfcmVncygpLCAtRVJFU1RB UlROT0lOVFIsIC0xKTsNCisJcmV0dXJuIC0xOw0KK30NCisNCisvKg0KKyAqIFRoaXMgcm91dGlu ZSBpcyBjYWxsZWQgZnJvbSBhbnkgZXhjZXB0aW9uIG9yIGlycSB0aGF0IGRvZXNuJ3QNCisgKiBv dGhlcndpc2UgdHJpZ2dlciBhIHNpZ25hbCB0byB0aGUgdXNlciBwcm9jZXNzIChlLmcuIHBhZ2Ug ZmF1bHQpLg0KKyAqDQorICogTWVzc2FnZXMgd2lsbCBiZSBzdXBwcmVzc2VkIGlmIHRoZXJlIGlz IGFscmVhZHkgYSByZXBvcnRlZCByZW1vdGUNCisgKiBjYXVzZSBmb3IgaXNvbGF0aW9uIGJyZWFr aW5nLCBzbyB3ZSBkb24ndCBnZW5lcmF0ZSBtdWx0aXBsZQ0KKyAqIGNvbmZ1c2luZ2x5IHNpbWls YXIgbWVzc2FnZXMgYWJvdXQgdGhlIHNhbWUgZXZlbnQuDQorICovDQordm9pZCBfdGFza19pc29s YXRpb25faW50ZXJydXB0KGNvbnN0IGNoYXIgKmZtdCwgLi4uKQ0KK3sNCisJc3RydWN0IHRhc2tf c3RydWN0ICp0YXNrID0gY3VycmVudDsNCisJdmFfbGlzdCBhcmdzOw0KKwljaGFyIGJ1ZlsxMDBd Ow0KKw0KKwkvKiBSQ1Ugc2hvdWxkIGhhdmUgYmVlbiBlbmFibGVkIHByaW9yIHRvIHRoaXMgcG9p bnQuICovDQorCVJDVV9MT0NLREVQX1dBUk4oIXJjdV9pc193YXRjaGluZygpLCAia2VybmVsIGVu dHJ5IHdpdGhvdXQgUkNVIik7DQorDQorCS8qIEFyZSB3ZSBleGl0aW5nIGlzb2xhdGlvbiBhbHJl YWR5PyAqLw0KKwlpZiAoYXRvbWljX3JlYWQoJnBlcl9jcHUoaXNvbF9leGl0X2NvdW50ZXIsIHNt cF9wcm9jZXNzb3JfaWQoKSkpICE9IDApIHsNCisJCXRhc2stPnRhc2tfaXNvbGF0aW9uX3N0YXRl ID0gU1RBVEVfTk9STUFMOw0KKwkJcmV0dXJuOw0KKwl9DQorCS8qDQorCSAqIEF2b2lkIHJlcG9y dGluZyBpbnRlcnJ1cHRzIHRoYXQgaGFwcGVuIGFmdGVyIHdlIGhhdmUgcHJjdGwnZWQNCisJICog dG8gZW5hYmxlIGlzb2xhdGlvbiwgYnV0IGJlZm9yZSB3ZSBoYXZlIHJldHVybmVkIHRvIHVzZXJz cGFjZS4NCisJICovDQorCWlmICh0YXNrLT50YXNrX2lzb2xhdGlvbl9zdGF0ZSA9PSBTVEFURV9O T1JNQUwpDQorCQlyZXR1cm47DQorDQorCXZhX3N0YXJ0KGFyZ3MsIGZtdCk7DQorCXZzbnByaW50 ZihidWYsIHNpemVvZihidWYpLCBmbXQsIGFyZ3MpOw0KKwl2YV9lbmQoYXJncyk7DQorDQorCS8q IEhhbmRsZSBOTUlzIG1pbmltYWxseSwgc2luY2Ugd2UgY2FuJ3Qgc2VuZCBhIHNpZ25hbC4gKi8N CisJaWYgKGluX25taSgpKSB7DQorCQlwcl90YXNrX2lzb2xfZXJyKHNtcF9wcm9jZXNzb3JfaWQo KSwNCisJCQkJICJpc29sYXRpb246IGluIE5NSTsgbm90IGRlbGl2ZXJpbmcgc2lnbmFsXG4iKTsN CisJfSBlbHNlIHsNCisJCXNlbmRfaXNvbGF0aW9uX3NpZ25hbCh0YXNrKTsNCisJfQ0KKw0KKwlp ZiAocHJfdGFza19pc29sX3dhcm5fc3VwcChzbXBfcHJvY2Vzc29yX2lkKCksDQorCQkJCSAgICJ0 YXNrX2lzb2xhdGlvbiBsb3N0IGR1ZSB0byAlc1xuIiwgYnVmKSkNCisJCWRlYnVnX2R1bXBfc3Rh Y2soKTsNCit9DQorDQorLyoNCisgKiBDYWxsZWQgYmVmb3JlIHdlIHdha2UgdXAgYSB0YXNrIHRo YXQgaGFzIGEgc2lnbmFsIHRvIHByb2Nlc3MuDQorICogTmVlZHMgdG8gYmUgZG9uZSB0byBoYW5k bGUgaW50ZXJydXB0cyB0aGF0IHRyaWdnZXIgc2lnbmFscywgd2hpY2gNCisgKiB3ZSBkb24ndCBj YXRjaCB3aXRoIHRhc2tfaXNvbGF0aW9uX2ludGVycnVwdCgpIGhvb2tzLg0KKyAqDQorICogVGhp cyBtZXNzYWdlIGlzIGFsc28gc3VwcHJlc3NlZCBpZiB0aGVyZSB3YXMgYWxyZWFkeSBhIHJlbW90 ZWx5DQorICogY2F1c2VkIG1lc3NhZ2UgYWJvdXQgdGhlIHNhbWUgaXNvbGF0aW9uIGJyZWFraW5n IGV2ZW50Lg0KKyAqLw0KK3ZvaWQgX3Rhc2tfaXNvbGF0aW9uX3NpZ25hbChzdHJ1Y3QgdGFza19z dHJ1Y3QgKnRhc2spDQorew0KKwlzdHJ1Y3QgaXNvbF90YXNrX2Rlc2MgKmRlc2M7DQorCWludCBp bmQsIGNwdTsNCisJYm9vbCBkb193YXJuID0gKHRhc2stPnRhc2tfaXNvbGF0aW9uX3N0YXRlID09 IFNUQVRFX0lTT0xBVEVEKTsNCisNCisJY3B1ID0gdGFza19jcHUodGFzayk7DQorCWRlc2MgPSAm cGVyX2NwdShpc29sX3Rhc2tfZGVzY3MsIGNwdSk7DQorCWluZCA9IGF0b21pY19yZWFkKCZkZXNj LT5jdXJyX2luZGV4KSAmIDE7DQorCWlmIChkZXNjLT53YXJuZWRbaW5kXSkNCisJCWRvX3dhcm4g PSBmYWxzZTsNCisNCisJc3RvcF9pc29sYXRpb24odGFzayk7DQorDQorCWlmIChkb193YXJuKSB7 DQorCQlwcl93YXJuKCJpc29sYXRpb246ICVzLyVkLyVkIChjcHUgJWQpOiB0YXNrX2lzb2xhdGlv biBsb3N0IGR1ZSB0byBzaWduYWxcbiIsDQorCQkJdGFzay0+Y29tbSwgdGFzay0+dGdpZCwgdGFz ay0+cGlkLCBjcHUpOw0KKwkJZGVidWdfZHVtcF9zdGFjaygpOw0KKwl9DQorfQ0KKw0KKy8qDQor ICogR2VuZXJhdGUgYSBzdGFjayBiYWNrdHJhY2UgaWYgd2UgYXJlIGdvaW5nIHRvIGludGVycnVw dCBhbm90aGVyIHRhc2sNCisgKiBpc29sYXRpb24gcHJvY2Vzcy4NCisgKi8NCit2b2lkIHRhc2tf aXNvbGF0aW9uX3JlbW90ZShpbnQgY3B1LCBjb25zdCBjaGFyICpmbXQsIC4uLikNCit7DQorCXN0 cnVjdCB0YXNrX3N0cnVjdCAqY3Vycl90YXNrOw0KKwl2YV9saXN0IGFyZ3M7DQorCWNoYXIgYnVm WzIwMF07DQorDQorCWlmICghaXNfaXNvbGF0aW9uX2NwdShjcHUpIHx8ICF0YXNrX2lzb2xhdGlv bl9vbl9jcHUoY3B1KSkNCisJCXJldHVybjsNCisNCisJY3Vycl90YXNrID0gY3VycmVudDsNCisN CisJdmFfc3RhcnQoYXJncywgZm10KTsNCisJdnNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksIGZt dCwgYXJncyk7DQorCXZhX2VuZChhcmdzKTsNCisJaWYgKHByX3Rhc2tfaXNvbF93YXJuKGNwdSwN CisJCQkgICAgICAidGFza19pc29sYXRpb24gbG9zdCBkdWUgdG8gJXMgYnkgJXMvJWQvJWQgb24g Y3B1ICVkXG4iLA0KKwkJCSAgICAgIGJ1ZiwNCisJCQkgICAgICBjdXJyX3Rhc2stPmNvbW0sIGN1 cnJfdGFzay0+dGdpZCwNCisJCQkgICAgICBjdXJyX3Rhc2stPnBpZCwgc21wX3Byb2Nlc3Nvcl9p ZCgpKSkNCisJCWRlYnVnX2R1bXBfc3RhY2soKTsNCit9DQorDQorLyoNCisgKiBHZW5lcmF0ZSBh IHN0YWNrIGJhY2t0cmFjZSBpZiBhbnkgb2YgdGhlIGNwdXMgaW4gIm1hc2siIGFyZSBydW5uaW5n DQorICogdGFzayBpc29sYXRpb24gcHJvY2Vzc2VzLg0KKyAqLw0KK3ZvaWQgdGFza19pc29sYXRp b25fcmVtb3RlX2NwdW1hc2soY29uc3Qgc3RydWN0IGNwdW1hc2sgKm1hc2ssDQorCQkJCSAgIGNv bnN0IGNoYXIgKmZtdCwgLi4uKQ0KK3sNCisJc3RydWN0IHRhc2tfc3RydWN0ICpjdXJyX3Rhc2s7 DQorCWNwdW1hc2tfdmFyX3Qgd2Fybl9tYXNrOw0KKwl2YV9saXN0IGFyZ3M7DQorCWNoYXIgYnVm WzIwMF07DQorCWludCBjcHUsIGZpcnN0X2NwdTsNCisNCisJaWYgKHRhc2tfaXNvbGF0aW9uX21h cCA9PSBOVUxMIHx8DQorCQkhemFsbG9jX2NwdW1hc2tfdmFyKCZ3YXJuX21hc2ssIEdGUF9LRVJO RUwpKQ0KKwkJcmV0dXJuOw0KKw0KKwlmaXJzdF9jcHUgPSAtMTsNCisJZm9yX2VhY2hfY3B1X2Fu ZChjcHUsIG1hc2ssIHRhc2tfaXNvbGF0aW9uX21hcCkgew0KKwkJaWYgKHRhc2tfaXNvbGF0aW9u X29uX2NwdShjcHUpKSB7DQorCQkJaWYgKGZpcnN0X2NwdSA8IDApDQorCQkJCWZpcnN0X2NwdSA9 IGNwdTsNCisJCQllbHNlDQorCQkJCWNwdW1hc2tfc2V0X2NwdShjcHUsIHdhcm5fbWFzayk7DQor CQl9DQorCX0NCisNCisJaWYgKGZpcnN0X2NwdSA8IDApDQorCQlnb3RvIGRvbmU7DQorDQorCWN1 cnJfdGFzayA9IGN1cnJlbnQ7DQorDQorCXZhX3N0YXJ0KGFyZ3MsIGZtdCk7DQorCXZzbnByaW50 ZihidWYsIHNpemVvZihidWYpLCBmbXQsIGFyZ3MpOw0KKwl2YV9lbmQoYXJncyk7DQorDQorCWlm IChjcHVtYXNrX3dlaWdodCh3YXJuX21hc2spID09IDApDQorCQlwcl90YXNrX2lzb2xfd2Fybihm aXJzdF9jcHUsDQorCQkJCSAgInRhc2tfaXNvbGF0aW9uIGxvc3QgZHVlIHRvICVzIGJ5ICVzLyVk LyVkIG9uIGNwdSAlZFxuIiwNCisJCQkJICBidWYsIGN1cnJfdGFzay0+Y29tbSwgY3Vycl90YXNr LT50Z2lkLA0KKwkJCQkgIGN1cnJfdGFzay0+cGlkLCBzbXBfcHJvY2Vzc29yX2lkKCkpOw0KKwll bHNlDQorCQlwcl90YXNrX2lzb2xfd2FybihmaXJzdF9jcHUsDQorCQkJCSAgIiBhbmQgY3B1cyAl KnBibDogdGFza19pc29sYXRpb24gbG9zdCBkdWUgdG8gJXMgYnkgJXMvJWQvJWQgb24gY3B1ICVk XG4iLA0KKwkJCQkgIGNwdW1hc2tfcHJfYXJncyh3YXJuX21hc2spLA0KKwkJCQkgIGJ1ZiwgY3Vy cl90YXNrLT5jb21tLCBjdXJyX3Rhc2stPnRnaWQsDQorCQkJCSAgY3Vycl90YXNrLT5waWQsIHNt cF9wcm9jZXNzb3JfaWQoKSk7DQorCWRlYnVnX2R1bXBfc3RhY2soKTsNCisNCitkb25lOg0KKwlm cmVlX2NwdW1hc2tfdmFyKHdhcm5fbWFzayk7DQorfQ0KKw0KKy8qDQorICogQ2hlY2sgaWYgZ2l2 ZW4gQ1BVIGlzIHJ1bm5pbmcgaXNvbGF0ZWQgdGFzay4NCisgKi8NCitpbnQgdGFza19pc29sYXRp b25fb25fY3B1KGludCBjcHUpDQorew0KKwlyZXR1cm4gdGVzdF9iaXQoVElGX1RBU0tfSVNPTEFU SU9OLA0KKwkJCSZwZXJfY3B1KHRza190aHJlYWRfZmxhZ3NfY2FjaGUsIGNwdSkpOw0KK30NCisN CisvKg0KKyAqIFNldCBDUFVzIGN1cnJlbnRseSBydW5uaW5nIGlzb2xhdGVkIHRhc2tzIGluIENQ VSBtYXNrLg0KKyAqLw0KK3ZvaWQgdGFza19pc29sYXRpb25fY3B1bWFzayhzdHJ1Y3QgY3B1bWFz ayAqbWFzaykNCit7DQorCWludCBjcHU7DQorDQorCWlmICh0YXNrX2lzb2xhdGlvbl9tYXAgPT0g TlVMTCkNCisJCXJldHVybjsNCisNCisJZm9yX2VhY2hfY3B1KGNwdSwgdGFza19pc29sYXRpb25f bWFwKQ0KKwkJaWYgKHRhc2tfaXNvbGF0aW9uX29uX2NwdShjcHUpKQ0KKwkJCWNwdW1hc2tfc2V0 X2NwdShjcHUsIG1hc2spOw0KK30NCisNCisvKg0KKyAqIENsZWFyIENQVXMgY3VycmVudGx5IHJ1 bm5pbmcgaXNvbGF0ZWQgdGFza3MgaW4gQ1BVIG1hc2suDQorICovDQordm9pZCB0YXNrX2lzb2xh dGlvbl9jbGVhcl9jcHVtYXNrKHN0cnVjdCBjcHVtYXNrICptYXNrKQ0KK3sNCisJaW50IGNwdTsN CisNCisJaWYgKHRhc2tfaXNvbGF0aW9uX21hcCA9PSBOVUxMKQ0KKwkJcmV0dXJuOw0KKw0KKwlm b3JfZWFjaF9jcHUoY3B1LCB0YXNrX2lzb2xhdGlvbl9tYXApDQorCQlpZiAodGFza19pc29sYXRp b25fb25fY3B1KGNwdSkpDQorCQkJY3B1bWFza19jbGVhcl9jcHUoY3B1LCBtYXNrKTsNCit9DQor DQorLyoNCisgKiBDbGVhbnVwIHByb2NlZHVyZS4gVGhlIGNhbGwgdG8gdGhpcyBwcm9jZWR1cmUg bWF5IGJlIGRlbGF5ZWQuDQorICovDQordm9pZCB0YXNrX2lzb2xhdGlvbl9jcHVfY2xlYW51cCh2 b2lkKQ0KK3sNCisJa2lja19ocnRpbWVyKCk7DQorfQ0KKw0KKy8qDQorICogQ2hlY2sgaWYgY2xl YW51cCBpcyBzY2hlZHVsZWQgb24gdGhlIGN1cnJlbnQgQ1BVLCBhbmQgaWYgc28sIHJ1biBpdC4N CisgKiBJbnRlbmRlZCB0byBiZSBjYWxsZWQgZnJvbSBub3RpZnlfcmVzdW1lKCkgb3IgYW5vdGhl ciBzdWNoIGNhbGxiYWNrDQorICogb24gdGhlIHRhcmdldCBDUFUuDQorICovDQordm9pZCB0YXNr X2lzb2xhdGlvbl9jaGVja19ydW5fY2xlYW51cCh2b2lkKQ0KK3sNCisJaW50IGNwdTsNCisJdW5z aWduZWQgbG9uZyBmbGFnczsNCisNCisJc3Bpbl9sb2NrX2lycXNhdmUoJnRhc2tfaXNvbGF0aW9u X2NsZWFudXBfbG9jaywgZmxhZ3MpOw0KKw0KKwljcHUgPSBzbXBfcHJvY2Vzc29yX2lkKCk7DQor DQorCWlmIChjcHVtYXNrX3Rlc3RfY3B1KGNwdSwgdGFza19pc29sYXRpb25fY2xlYW51cF9tYXAp KSB7DQorCQljcHVtYXNrX2NsZWFyX2NwdShjcHUsIHRhc2tfaXNvbGF0aW9uX2NsZWFudXBfbWFw KTsNCisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnRhc2tfaXNvbGF0aW9uX2NsZWFudXBfbG9j aywgZmxhZ3MpOw0KKwkJdGFza19pc29sYXRpb25fY3B1X2NsZWFudXAoKTsNCisJfSBlbHNlDQor CQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ0YXNrX2lzb2xhdGlvbl9jbGVhbnVwX2xvY2ssIGZs YWdzKTsNCit9DQpkaWZmIC0tZ2l0IGEva2VybmVsL3NpZ25hbC5jIGIva2VybmVsL3NpZ25hbC5j DQppbmRleCA1YjIzOTYzNTBkZDEuLjFkZjU3ZTM4YzM2MSAxMDA2NDQNCi0tLSBhL2tlcm5lbC9z aWduYWwuYw0KKysrIGIva2VybmVsL3NpZ25hbC5jDQpAQCAtNDYsNiArNDYsNyBAQA0KICNpbmNs dWRlIDxsaW51eC9saXZlcGF0Y2guaD4NCiAjaW5jbHVkZSA8bGludXgvY2dyb3VwLmg+DQogI2lu Y2x1ZGUgPGxpbnV4L2F1ZGl0Lmg+DQorI2luY2x1ZGUgPGxpbnV4L2lzb2xhdGlvbi5oPg0KIA0K ICNkZWZpbmUgQ1JFQVRFX1RSQUNFX1BPSU5UUw0KICNpbmNsdWRlIDx0cmFjZS9ldmVudHMvc2ln bmFsLmg+DQpAQCAtNzU4LDYgKzc1OSw3IEBAIHN0YXRpYyBpbnQgZGVxdWV1ZV9zeW5jaHJvbm91 c19zaWduYWwoa2VybmVsX3NpZ2luZm9fdCAqaW5mbykNCiAgKi8NCiB2b2lkIHNpZ25hbF93YWtl X3VwX3N0YXRlKHN0cnVjdCB0YXNrX3N0cnVjdCAqdCwgdW5zaWduZWQgaW50IHN0YXRlKQ0KIHsN CisJdGFza19pc29sYXRpb25fc2lnbmFsKHQpOw0KIAlzZXRfdHNrX3RocmVhZF9mbGFnKHQsIFRJ Rl9TSUdQRU5ESU5HKTsNCiAJLyoNCiAJICogVEFTS19XQUtFS0lMTCBhbHNvIG1lYW5zIHdha2Ug aXQgdXAgaW4gdGhlIHN0b3BwZWQvdHJhY2VkL2tpbGxhYmxlDQpkaWZmIC0tZ2l0IGEva2VybmVs L3N5cy5jIGIva2VybmVsL3N5cy5jDQppbmRleCBmOWJjNWMzMDNlM2YuLjBhNDA1OWE4YzRmOSAx MDA2NDQNCi0tLSBhL2tlcm5lbC9zeXMuYw0KKysrIGIva2VybmVsL3N5cy5jDQpAQCAtNDIsNiAr NDIsNyBAQA0KICNpbmNsdWRlIDxsaW51eC9zeXNjb3JlX29wcy5oPg0KICNpbmNsdWRlIDxsaW51 eC92ZXJzaW9uLmg+DQogI2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+DQorI2luY2x1ZGUgPGxpbnV4 L2lzb2xhdGlvbi5oPg0KIA0KICNpbmNsdWRlIDxsaW51eC9jb21wYXQuaD4NCiAjaW5jbHVkZSA8 bGludXgvc3lzY2FsbHMuaD4NCkBAIC0yNTEzLDYgKzI1MTQsMTEgQEAgU1lTQ0FMTF9ERUZJTkU1 KHByY3RsLCBpbnQsIG9wdGlvbiwgdW5zaWduZWQgbG9uZywgYXJnMiwgdW5zaWduZWQgbG9uZywg YXJnMywNCiANCiAJCWVycm9yID0gKGN1cnJlbnQtPmZsYWdzICYgUFJfSU9fRkxVU0hFUikgPT0g UFJfSU9fRkxVU0hFUjsNCiAJCWJyZWFrOw0KKwljYXNlIFBSX1RBU0tfSVNPTEFUSU9OOg0KKwkJ aWYgKGFyZzMgfHwgYXJnNCB8fCBhcmc1KQ0KKwkJCXJldHVybiAtRUlOVkFMOw0KKwkJZXJyb3Ig PSB0YXNrX2lzb2xhdGlvbl9yZXF1ZXN0KGFyZzIpOw0KKwkJYnJlYWs7DQogCWRlZmF1bHQ6DQog CQllcnJvciA9IC1FSU5WQUw7DQogCQlicmVhazsNCmRpZmYgLS1naXQgYS9rZXJuZWwvdGltZS9o cnRpbWVyLmMgYi9rZXJuZWwvdGltZS9ocnRpbWVyLmMNCmluZGV4IDNhNjA5ZTczNDRmMy4uNWJi OThmMzliZGU2IDEwMDY0NA0KLS0tIGEva2VybmVsL3RpbWUvaHJ0aW1lci5jDQorKysgYi9rZXJu ZWwvdGltZS9ocnRpbWVyLmMNCkBAIC0zMCw2ICszMCw3IEBADQogI2luY2x1ZGUgPGxpbnV4L3N5 c2NhbGxzLmg+DQogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPg0KICNpbmNsdWRlIDxsaW51 eC90aWNrLmg+DQorI2luY2x1ZGUgPGxpbnV4L2lzb2xhdGlvbi5oPg0KICNpbmNsdWRlIDxsaW51 eC9lcnIuaD4NCiAjaW5jbHVkZSA8bGludXgvZGVidWdvYmplY3RzLmg+DQogI2luY2x1ZGUgPGxp bnV4L3NjaGVkL3NpZ25hbC5oPg0KQEAgLTcyMSw2ICs3MjIsMTkgQEAgc3RhdGljIHZvaWQgcmV0 cmlnZ2VyX25leHRfZXZlbnQodm9pZCAqYXJnKQ0KIAlyYXdfc3Bpbl91bmxvY2soJmJhc2UtPmxv Y2spOw0KIH0NCiANCisjaWZkZWYgQ09ORklHX1RBU0tfSVNPTEFUSU9ODQordm9pZCBraWNrX2hy dGltZXIodm9pZCkNCit7DQorCXVuc2lnbmVkIGxvbmcgZmxhZ3M7DQorDQorCXByZWVtcHRfZGlz YWJsZSgpOw0KKwlsb2NhbF9pcnFfc2F2ZShmbGFncyk7DQorCXJldHJpZ2dlcl9uZXh0X2V2ZW50 KE5VTEwpOw0KKwlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7DQorCXByZWVtcHRfZW5hYmxlKCk7 DQorfQ0KKyNlbmRpZg0KKw0KIC8qDQogICogU3dpdGNoIHRvIGhpZ2ggcmVzb2x1dGlvbiBtb2Rl DQogICovDQpAQCAtODY4LDggKzg4MiwyMSBAQCBzdGF0aWMgdm9pZCBocnRpbWVyX3JlcHJvZ3Jh bShzdHJ1Y3QgaHJ0aW1lciAqdGltZXIsIGJvb2wgcmVwcm9ncmFtKQ0KIHZvaWQgY2xvY2tfd2Fz X3NldCh2b2lkKQ0KIHsNCiAjaWZkZWYgQ09ORklHX0hJR0hfUkVTX1RJTUVSUw0KKyNpZmRlZiBD T05GSUdfVEFTS19JU09MQVRJT04NCisJc3RydWN0IGNwdW1hc2sgbWFzazsNCisNCisJY3B1bWFz a19jbGVhcigmbWFzayk7DQorCXRhc2tfaXNvbGF0aW9uX2NwdW1hc2soJm1hc2spOw0KKwljcHVt YXNrX2NvbXBsZW1lbnQoJm1hc2ssICZtYXNrKTsNCisJLyoNCisJICogUmV0cmlnZ2VyIHRoZSBD UFUgbG9jYWwgZXZlbnRzIGV2ZXJ5d2hlcmUgZXhjZXB0IENQVXMNCisJICogcnVubmluZyBpc29s YXRlZCB0YXNrcy4NCisJICovDQorCW9uX2VhY2hfY3B1X21hc2soJm1hc2ssIHJldHJpZ2dlcl9u ZXh0X2V2ZW50LCBOVUxMLCAxKTsNCisjZWxzZQ0KIAkvKiBSZXRyaWdnZXIgdGhlIENQVSBsb2Nh bCBldmVudHMgZXZlcnl3aGVyZSAqLw0KIAlvbl9lYWNoX2NwdShyZXRyaWdnZXJfbmV4dF9ldmVu dCwgTlVMTCwgMSk7DQorI2VuZGlmDQogI2VuZGlmDQogCXRpbWVyZmRfY2xvY2tfd2FzX3NldCgp Ow0KIH0NCmRpZmYgLS1naXQgYS9rZXJuZWwvdGltZS90aWNrLXNjaGVkLmMgYi9rZXJuZWwvdGlt ZS90aWNrLXNjaGVkLmMNCmluZGV4IGE3OTJkMjFjYWM2NC4uMWQ0ZGVjOWQzZWU3IDEwMDY0NA0K LS0tIGEva2VybmVsL3RpbWUvdGljay1zY2hlZC5jDQorKysgYi9rZXJuZWwvdGltZS90aWNrLXNj aGVkLmMNCkBAIC04ODIsNiArODgyLDI0IEBAIHN0YXRpYyB2b2lkIHRpY2tfbm9oel9mdWxsX3Vw ZGF0ZV90aWNrKHN0cnVjdCB0aWNrX3NjaGVkICp0cykNCiAjZW5kaWYNCiB9DQogDQorI2lmZGVm IENPTkZJR19UQVNLX0lTT0xBVElPTg0KK2ludCB0cnlfc3RvcF9mdWxsX3RpY2sodm9pZCkNCit7 DQorCWludCBjcHUgPSBzbXBfcHJvY2Vzc29yX2lkKCk7DQorCXN0cnVjdCB0aWNrX3NjaGVkICp0 cyA9IHRoaXNfY3B1X3B0cigmdGlja19jcHVfc2NoZWQpOw0KKw0KKwkvKiBGb3IgYW4gdW5zdGFi bGUgY2xvY2ssIHdlIHNob3VsZCByZXR1cm4gYSBwZXJtYW5lbnQgZXJyb3IgY29kZS4gKi8NCisJ aWYgKGF0b21pY19yZWFkKCZ0aWNrX2RlcF9tYXNrKSAmIFRJQ0tfREVQX01BU0tfQ0xPQ0tfVU5T VEFCTEUpDQorCQlyZXR1cm4gLUVJTlZBTDsNCisNCisJaWYgKCFjYW5fc3RvcF9mdWxsX3RpY2so Y3B1LCB0cykpDQorCQlyZXR1cm4gLUVBR0FJTjsNCisNCisJdGlja19ub2h6X3N0b3Bfc2NoZWRf dGljayh0cywgY3B1KTsNCisJcmV0dXJuIDA7DQorfQ0KKyNlbmRpZg0KKw0KIHN0YXRpYyBib29s IGNhbl9zdG9wX2lkbGVfdGljayhpbnQgY3B1LCBzdHJ1Y3QgdGlja19zY2hlZCAqdHMpDQogew0K IAkvKg0KLS0gDQoyLjIwLjENCg0K