From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1F8C3C433EF for ; Fri, 4 Mar 2022 10:49:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237935AbiCDKtt (ORCPT ); Fri, 4 Mar 2022 05:49:49 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:39854 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230507AbiCDKtp (ORCPT ); Fri, 4 Mar 2022 05:49:45 -0500 Received: from smtp-42a8.mail.infomaniak.ch (smtp-42a8.mail.infomaniak.ch [84.16.66.168]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A8EB341F86 for ; Fri, 4 Mar 2022 02:48:55 -0800 (PST) Received: from smtp-3-0001.mail.infomaniak.ch (unknown [10.4.36.108]) by smtp-3-3000.mail.infomaniak.ch (Postfix) with ESMTPS id 4K94N55qFQzMqLlC; Fri, 4 Mar 2022 11:48:53 +0100 (CET) Received: from ns3096276.ip-94-23-54.eu (unknown [23.97.221.149]) by smtp-3-0001.mail.infomaniak.ch (Postfix) with ESMTPA id 4K94N347yKzlhMC7; Fri, 4 Mar 2022 11:48:51 +0100 (CET) Message-ID: Date: Fri, 4 Mar 2022 11:48:58 +0100 MIME-Version: 1.0 User-Agent: Content-Language: en-US To: Casey Schaufler , casey.schaufler@intel.com, jmorris@namei.org, linux-security-module@vger.kernel.org, selinux@vger.kernel.org Cc: linux-audit@redhat.com, keescook@chromium.org, john.johansen@canonical.com, penguin-kernel@i-love.sakura.ne.jp, paul@paul-moore.com, sds@tycho.nsa.gov, linux-kernel@vger.kernel.org References: <20220202235323.23929-1-casey@schaufler-ca.com> <20220202235323.23929-4-casey@schaufler-ca.com> From: =?UTF-8?Q?Micka=c3=abl_Sala=c3=bcn?= Subject: Re: [PATCH v32 03/28] LSM: Add the lsmblob data structure. In-Reply-To: <20220202235323.23929-4-casey@schaufler-ca.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 03/02/2022 00:52, Casey Schaufler wrote: > When more than one security module is exporting data to > audit and networking sub-systems a single 32 bit integer > is no longer sufficient to represent the data. Add a > structure to be used instead. > > The lsmblob structure is currently an array of > u32 "secids". There is an entry for each of the > security modules built into the system that would > use secids if active. The system assigns the module > a "slot" when it registers hooks. If modules are > compiled in but not registered there will be unused > slots. > > A new lsm_id structure, which contains the name > of the LSM and its slot number, is created. There > is an instance for each LSM, which assigns the name > and passes it to the infrastructure to set the slot. > > The audit rules data is expanded to use an array of > security module data rather than a single instance. > A new structure audit_lsm_rules is defined to avoid the > confusion which commonly accompanies the use of > void ** parameters. > > Signed-off-by: Casey Schaufler Reviewed-by: Mickaël Salaün Minor fixes: > --- > include/linux/audit.h | 10 ++++- > include/linux/lsm_hooks.h | 12 +++++- > include/linux/security.h | 74 +++++++++++++++++++++++++++++--- > kernel/auditfilter.c | 23 +++++----- > kernel/auditsc.c | 17 +++----- > security/apparmor/lsm.c | 7 ++- > security/bpf/hooks.c | 12 +++++- > security/commoncap.c | 7 ++- > security/landlock/cred.c | 2 +- > security/landlock/fs.c | 2 +- > security/landlock/ptrace.c | 2 +- > security/landlock/setup.c | 5 +++ > security/landlock/setup.h | 1 + > security/loadpin/loadpin.c | 8 +++- > security/lockdown/lockdown.c | 7 ++- > security/safesetid/lsm.c | 8 +++- > security/security.c | 82 ++++++++++++++++++++++++++++++------ > security/selinux/hooks.c | 8 +++- > security/smack/smack_lsm.c | 7 ++- > security/tomoyo/tomoyo.c | 8 +++- > security/yama/yama_lsm.c | 7 ++- > 21 files changed, 253 insertions(+), 56 deletions(-) > > diff --git a/include/linux/audit.h b/include/linux/audit.h > index d06134ac6245..14849d5f84b4 100644 > --- a/include/linux/audit.h > +++ b/include/linux/audit.h > @@ -11,6 +11,7 @@ > > #include > #include > +#include > #include > #include > #include > @@ -59,6 +60,10 @@ struct audit_krule { > /* Flag to indicate legacy AUDIT_LOGINUID unset usage */ > #define AUDIT_LOGINUID_LEGACY 0x1 > > +struct audit_lsm_rules { > + void *rule[LSMBLOB_ENTRIES]; > +}; > + > struct audit_field { > u32 type; > union { > @@ -66,8 +71,9 @@ struct audit_field { > kuid_t uid; > kgid_t gid; > struct { > - char *lsm_str; > - void *lsm_rule; > + bool lsm_isset; > + char *lsm_str; > + struct audit_lsm_rules lsm_rules; > }; > }; > u32 op; > diff --git a/include/linux/lsm_hooks.h b/include/linux/lsm_hooks.h > index 129d99c6f9ed..2c2d0ef59a41 100644 > --- a/include/linux/lsm_hooks.h > +++ b/include/linux/lsm_hooks.h > @@ -1582,6 +1582,14 @@ struct security_hook_heads { > #undef LSM_HOOK > } __randomize_layout; > > +/* > + * Information that identifies a security module. > + */ > +struct lsm_id { > + const char *lsm; /* Name of the LSM */ > + int slot; /* Slot in lsmblob if one is allocated */ > +}; > + > /* > * Security module hook list structure. > * For use with generic list macros for common operations. > @@ -1590,7 +1598,7 @@ struct security_hook_list { > struct hlist_node list; > struct hlist_head *head; > union security_list_options hook; > - char *lsm; > + struct lsm_id *lsmid; > } __randomize_layout; > > /* > @@ -1626,7 +1634,7 @@ extern struct security_hook_heads security_hook_heads; > extern char *lsm_names; > > extern void security_add_hooks(struct security_hook_list *hooks, int count, > - char *lsm); > + struct lsm_id *lsmid); > > #define LSM_FLAG_LEGACY_MAJOR BIT(0) > #define LSM_FLAG_EXCLUSIVE BIT(1) > diff --git a/include/linux/security.h b/include/linux/security.h > index 33e0f2e659df..1a7e5bf36a82 100644 > --- a/include/linux/security.h > +++ b/include/linux/security.h > @@ -39,6 +39,7 @@ struct kernel_siginfo; > struct sembuf; > struct kern_ipc_perm; > struct audit_context; > +struct audit_lsm_rules; > struct super_block; > struct inode; > struct dentry; > @@ -134,6 +135,65 @@ enum lockdown_reason { > > extern const char *const lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1]; > > +/* > + * Data exported by the security modules > + * > + * Any LSM that provides secid or secctx based hooks must be included. > + */ > +#define LSMBLOB_ENTRIES ( \ > + (IS_ENABLED(CONFIG_SECURITY_SELINUX) ? 1 : 0) + \ > + (IS_ENABLED(CONFIG_SECURITY_SMACK) ? 1 : 0) + \ > + (IS_ENABLED(CONFIG_SECURITY_APPARMOR) ? 1 : 0) + \ > + (IS_ENABLED(CONFIG_BPF_LSM) ? 1 : 0)) > + > +struct lsmblob { > + u32 secid[LSMBLOB_ENTRIES]; > +}; > + > +#define LSMBLOB_INVALID -1 /* Not a valid LSM slot number */ > +#define LSMBLOB_NEEDED -2 /* Slot requested on initialization */ > +#define LSMBLOB_NOT_NEEDED -3 /* Slot not requested */ > + > +/** > + * lsmblob_init - initialize an lsmblob structure > + * @blob: Pointer to the data to initialize > + * @secid: The initial secid value > + * > + * Set all secid for all modules to the specified value. > + */ > +static inline void lsmblob_init(struct lsmblob *blob, u32 secid) > +{ > + int i; > + > + for (i = 0; i < LSMBLOB_ENTRIES; i++) > + blob->secid[i] = secid; > +} > + > +/** > + * lsmblob_is_set - report if there is an value in the lsmblob *a* value > + * @blob: Pointer to the exported LSM data > + * > + * Returns true if there is a secid set, false otherwise > + */ > +static inline bool lsmblob_is_set(struct lsmblob *blob) > +{ > + struct lsmblob empty = {}; const struct lsmblob empty = {}; > + > + return !!memcmp(blob, &empty, sizeof(*blob)); > +} > + > +/** > + * lsmblob_equal - report if the two lsmblob's are equal > + * @bloba: Pointer to one LSM data > + * @blobb: Pointer to the other LSM data > + * > + * Returns true if all entries in the two are equal, false otherwise > + */ > +static inline bool lsmblob_equal(struct lsmblob *bloba, struct lsmblob *blobb) const struct lsmblob *bloba, const struct lsmblob *blobb > +{ > + return !memcmp(bloba, blobb, sizeof(*bloba)); > +} > + > /* These functions are in security/commoncap.c */ > extern int cap_capable(const struct cred *cred, struct user_namespace *ns, > int cap, unsigned int opts); > @@ -1879,15 +1939,17 @@ static inline int security_key_getsecurity(struct key *key, char **_buffer) > > #ifdef CONFIG_AUDIT > #ifdef CONFIG_SECURITY > -int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule); > +int security_audit_rule_init(u32 field, u32 op, char *rulestr, > + struct audit_lsm_rules *lsmrules); > int security_audit_rule_known(struct audit_krule *krule); > -int security_audit_rule_match(u32 secid, u32 field, u32 op, void *lsmrule); > -void security_audit_rule_free(void *lsmrule); > +int security_audit_rule_match(u32 secid, u32 field, u32 op, > + struct audit_lsm_rules *lsmrules); > +void security_audit_rule_free(struct audit_lsm_rules *lsmrules); > > #else > > static inline int security_audit_rule_init(u32 field, u32 op, char *rulestr, > - void **lsmrule) > + struct audit_lsm_rules *lsmrules) > { > return 0; > } > @@ -1898,12 +1960,12 @@ static inline int security_audit_rule_known(struct audit_krule *krule) > } > > static inline int security_audit_rule_match(u32 secid, u32 field, u32 op, > - void *lsmrule) > + struct audit_lsm_rules *lsmrules) > { > return 0; > } > > -static inline void security_audit_rule_free(void *lsmrule) > +static inline void security_audit_rule_free(struct audit_lsm_rules *lsmrules) > { } > > #endif /* CONFIG_SECURITY */ > diff --git a/kernel/auditfilter.c b/kernel/auditfilter.c > index 42d99896e7a6..de75bd6ad866 100644 > --- a/kernel/auditfilter.c > +++ b/kernel/auditfilter.c > @@ -76,7 +76,7 @@ static void audit_free_lsm_field(struct audit_field *f) > case AUDIT_OBJ_LEV_LOW: > case AUDIT_OBJ_LEV_HIGH: > kfree(f->lsm_str); > - security_audit_rule_free(f->lsm_rule); > + security_audit_rule_free(&f->lsm_rules); > } > } > > @@ -529,7 +529,7 @@ static struct audit_entry *audit_data_to_entry(struct audit_rule_data *data, > entry->rule.buflen += f_val; > f->lsm_str = str; > err = security_audit_rule_init(f->type, f->op, str, > - (void **)&f->lsm_rule); > + &f->lsm_rules); > /* Keep currently invalid fields around in case they > * become valid after a policy reload. */ > if (err == -EINVAL) { > @@ -782,7 +782,7 @@ static int audit_compare_rule(struct audit_krule *a, struct audit_krule *b) > return 0; > } > > -/* Duplicate LSM field information. The lsm_rule is opaque, so must be > +/* Duplicate LSM field information. The lsm_rules is opaque, so must be > * re-initialized. */ > static inline int audit_dupe_lsm_field(struct audit_field *df, > struct audit_field *sf) > @@ -796,9 +796,9 @@ static inline int audit_dupe_lsm_field(struct audit_field *df, > return -ENOMEM; > df->lsm_str = lsm_str; > > - /* our own (refreshed) copy of lsm_rule */ > + /* our own (refreshed) copy of lsm_rules */ > ret = security_audit_rule_init(df->type, df->op, df->lsm_str, > - (void **)&df->lsm_rule); > + &df->lsm_rules); > /* Keep currently invalid fields around in case they > * become valid after a policy reload. */ > if (ret == -EINVAL) { > @@ -850,7 +850,7 @@ struct audit_entry *audit_dupe_rule(struct audit_krule *old) > new->tree = old->tree; > memcpy(new->fields, old->fields, sizeof(struct audit_field) * fcount); > > - /* deep copy this information, updating the lsm_rule fields, because > + /* deep copy this information, updating the lsm_rules fields, because > * the originals will all be freed when the old rule is freed. */ > for (i = 0; i < fcount; i++) { > switch (new->fields[i].type) { > @@ -1367,10 +1367,11 @@ int audit_filter(int msgtype, unsigned int listtype) > case AUDIT_SUBJ_TYPE: > case AUDIT_SUBJ_SEN: > case AUDIT_SUBJ_CLR: > - if (f->lsm_rule) { > + if (f->lsm_str) { > security_current_getsecid_subj(&sid); > result = security_audit_rule_match(sid, > - f->type, f->op, f->lsm_rule); > + f->type, f->op, > + &f->lsm_rules); > } > break; > case AUDIT_EXE: > @@ -1397,7 +1398,7 @@ int audit_filter(int msgtype, unsigned int listtype) > return ret; > } > > -static int update_lsm_rule(struct audit_krule *r) > +static int update_lsm_rules(struct audit_krule *r) > { > struct audit_entry *entry = container_of(r, struct audit_entry, rule); > struct audit_entry *nentry; > @@ -1429,7 +1430,7 @@ static int update_lsm_rule(struct audit_krule *r) > return err; > } > > -/* This function will re-initialize the lsm_rule field of all applicable rules. > +/* This function will re-initialize the lsm_rules field of all applicable rules. > * It will traverse the filter lists serarching for rules that contain LSM > * specific filter fields. When such a rule is found, it is copied, the > * LSM field is re-initialized, and the old rule is replaced with the > @@ -1444,7 +1445,7 @@ int audit_update_lsm_rules(void) > > for (i = 0; i < AUDIT_NR_FILTERS; i++) { > list_for_each_entry_safe(r, n, &audit_rules_list[i], list) { > - int res = update_lsm_rule(r); > + int res = update_lsm_rules(r); > if (!err) > err = res; > } > diff --git a/kernel/auditsc.c b/kernel/auditsc.c > index fce5d43a933f..f1c26a322f9d 100644 > --- a/kernel/auditsc.c > +++ b/kernel/auditsc.c > @@ -664,7 +664,7 @@ static int audit_filter_rules(struct task_struct *tsk, > match for now to avoid losing information that > may be wanted. An error message will also be > logged upon error */ > - if (f->lsm_rule) { > + if (f->lsm_str) { > if (need_sid) { > /* @tsk should always be equal to > * @current with the exception of > @@ -679,8 +679,7 @@ static int audit_filter_rules(struct task_struct *tsk, > need_sid = 0; > } > result = security_audit_rule_match(sid, f->type, > - f->op, > - f->lsm_rule); > + f->op, &f->lsm_rules); > } > break; > case AUDIT_OBJ_USER: > @@ -690,21 +689,19 @@ static int audit_filter_rules(struct task_struct *tsk, > case AUDIT_OBJ_LEV_HIGH: > /* The above note for AUDIT_SUBJ_USER...AUDIT_SUBJ_CLR > also applies here */ > - if (f->lsm_rule) { > + if (f->lsm_str) { > /* Find files that match */ > if (name) { > result = security_audit_rule_match( > name->osid, > f->type, > f->op, > - f->lsm_rule); > + &f->lsm_rules); > } else if (ctx) { > list_for_each_entry(n, &ctx->names_list, list) { > if (security_audit_rule_match( > - n->osid, > - f->type, > - f->op, > - f->lsm_rule)) { > + n->osid, f->type, f->op, > + &f->lsm_rules)) { > ++result; > break; > } > @@ -715,7 +712,7 @@ static int audit_filter_rules(struct task_struct *tsk, > break; > if (security_audit_rule_match(ctx->ipc.osid, > f->type, f->op, > - f->lsm_rule)) > + &f->lsm_rules)) > ++result; > } > break; > diff --git a/security/apparmor/lsm.c b/security/apparmor/lsm.c > index be8976c407f4..1e53fea61335 100644 > --- a/security/apparmor/lsm.c > +++ b/security/apparmor/lsm.c > @@ -1168,6 +1168,11 @@ struct lsm_blob_sizes apparmor_blob_sizes __lsm_ro_after_init = { > .lbs_sock = sizeof(struct aa_sk_ctx), > }; > > +static struct lsm_id apparmor_lsmid __lsm_ro_after_init = { > + .lsm = "apparmor", > + .slot = LSMBLOB_NEEDED > +}; > + > static struct security_hook_list apparmor_hooks[] __lsm_ro_after_init = { > LSM_HOOK_INIT(ptrace_access_check, apparmor_ptrace_access_check), > LSM_HOOK_INIT(ptrace_traceme, apparmor_ptrace_traceme), > @@ -1853,7 +1858,7 @@ static int __init apparmor_init(void) > goto buffers_out; > } > security_add_hooks(apparmor_hooks, ARRAY_SIZE(apparmor_hooks), > - "apparmor"); > + &apparmor_lsmid); > > /* Report that AppArmor successfully initialized */ > apparmor_initialized = 1; > diff --git a/security/bpf/hooks.c b/security/bpf/hooks.c > index e5971fa74fd7..7a58fe9ab8c4 100644 > --- a/security/bpf/hooks.c > +++ b/security/bpf/hooks.c > @@ -15,9 +15,19 @@ static struct security_hook_list bpf_lsm_hooks[] __lsm_ro_after_init = { > LSM_HOOK_INIT(task_free, bpf_task_storage_free), > }; > > +/* > + * slot has to be LSMBLOB_NEEDED because some of the hooks > + * supplied by this module require a slot. > + */ > +struct lsm_id bpf_lsmid __lsm_ro_after_init = { > + .lsm = "bpf", > + .slot = LSMBLOB_NEEDED > +}; > + > static int __init bpf_lsm_init(void) > { > - security_add_hooks(bpf_lsm_hooks, ARRAY_SIZE(bpf_lsm_hooks), "bpf"); > + security_add_hooks(bpf_lsm_hooks, ARRAY_SIZE(bpf_lsm_hooks), > + &bpf_lsmid); > pr_info("LSM support for eBPF active\n"); > return 0; > } > diff --git a/security/commoncap.c b/security/commoncap.c > index 5fc8986c3c77..c94ec46e07ac 100644 > --- a/security/commoncap.c > +++ b/security/commoncap.c > @@ -1446,6 +1446,11 @@ int cap_mmap_file(struct file *file, unsigned long reqprot, > > #ifdef CONFIG_SECURITY > > +static struct lsm_id capability_lsmid __lsm_ro_after_init = { > + .lsm = "capability", > + .slot = LSMBLOB_NOT_NEEDED > +}; > + > static struct security_hook_list capability_hooks[] __lsm_ro_after_init = { > LSM_HOOK_INIT(capable, cap_capable), > LSM_HOOK_INIT(settime, cap_settime), > @@ -1470,7 +1475,7 @@ static struct security_hook_list capability_hooks[] __lsm_ro_after_init = { > static int __init capability_init(void) > { > security_add_hooks(capability_hooks, ARRAY_SIZE(capability_hooks), > - "capability"); > + &capability_lsmid); > return 0; > } > > diff --git a/security/landlock/cred.c b/security/landlock/cred.c > index 6725af24c684..56b121d65436 100644 > --- a/security/landlock/cred.c > +++ b/security/landlock/cred.c > @@ -42,5 +42,5 @@ static struct security_hook_list landlock_hooks[] __lsm_ro_after_init = { > __init void landlock_add_cred_hooks(void) > { > security_add_hooks(landlock_hooks, ARRAY_SIZE(landlock_hooks), > - LANDLOCK_NAME); > + &landlock_lsmid); > } > diff --git a/security/landlock/fs.c b/security/landlock/fs.c > index 97b8e421f617..319e90e9290c 100644 > --- a/security/landlock/fs.c > +++ b/security/landlock/fs.c > @@ -688,5 +688,5 @@ static struct security_hook_list landlock_hooks[] __lsm_ro_after_init = { > __init void landlock_add_fs_hooks(void) > { > security_add_hooks(landlock_hooks, ARRAY_SIZE(landlock_hooks), > - LANDLOCK_NAME); > + &landlock_lsmid); > } > diff --git a/security/landlock/ptrace.c b/security/landlock/ptrace.c > index f55b82446de2..54ccf55a077a 100644 > --- a/security/landlock/ptrace.c > +++ b/security/landlock/ptrace.c > @@ -116,5 +116,5 @@ static struct security_hook_list landlock_hooks[] __lsm_ro_after_init = { > __init void landlock_add_ptrace_hooks(void) > { > security_add_hooks(landlock_hooks, ARRAY_SIZE(landlock_hooks), > - LANDLOCK_NAME); > + &landlock_lsmid); > } > diff --git a/security/landlock/setup.c b/security/landlock/setup.c > index f8e8e980454c..759e00b9436c 100644 > --- a/security/landlock/setup.c > +++ b/security/landlock/setup.c > @@ -23,6 +23,11 @@ struct lsm_blob_sizes landlock_blob_sizes __lsm_ro_after_init = { > .lbs_superblock = sizeof(struct landlock_superblock_security), > }; > > +struct lsm_id landlock_lsmid __lsm_ro_after_init = { > + .lsm = LANDLOCK_NAME, > + .slot = LSMBLOB_NOT_NEEDED, > +}; > + > static int __init landlock_init(void) > { > landlock_add_cred_hooks(); > diff --git a/security/landlock/setup.h b/security/landlock/setup.h > index 1daffab1ab4b..38bce5b172dc 100644 > --- a/security/landlock/setup.h > +++ b/security/landlock/setup.h > @@ -14,5 +14,6 @@ > extern bool landlock_initialized; > > extern struct lsm_blob_sizes landlock_blob_sizes; > +extern struct lsm_id landlock_lsmid; > > #endif /* _SECURITY_LANDLOCK_SETUP_H */ > diff --git a/security/loadpin/loadpin.c b/security/loadpin/loadpin.c > index b12f7d986b1e..b569f3bc170b 100644 > --- a/security/loadpin/loadpin.c > +++ b/security/loadpin/loadpin.c > @@ -192,6 +192,11 @@ static int loadpin_load_data(enum kernel_load_data_id id, bool contents) > return loadpin_read_file(NULL, (enum kernel_read_file_id) id, contents); > } > > +static struct lsm_id loadpin_lsmid __lsm_ro_after_init = { > + .lsm = "loadpin", > + .slot = LSMBLOB_NOT_NEEDED > +}; > + > static struct security_hook_list loadpin_hooks[] __lsm_ro_after_init = { > LSM_HOOK_INIT(sb_free_security, loadpin_sb_free_security), > LSM_HOOK_INIT(kernel_read_file, loadpin_read_file), > @@ -239,7 +244,8 @@ static int __init loadpin_init(void) > pr_info("ready to pin (currently %senforcing)\n", > enforce ? "" : "not "); > parse_exclude(); > - security_add_hooks(loadpin_hooks, ARRAY_SIZE(loadpin_hooks), "loadpin"); > + security_add_hooks(loadpin_hooks, ARRAY_SIZE(loadpin_hooks), > + &loadpin_lsmid); > return 0; > } > > diff --git a/security/lockdown/lockdown.c b/security/lockdown/lockdown.c > index 87cbdc64d272..4e24ea3f7b7e 100644 > --- a/security/lockdown/lockdown.c > +++ b/security/lockdown/lockdown.c > @@ -75,6 +75,11 @@ static struct security_hook_list lockdown_hooks[] __lsm_ro_after_init = { > LSM_HOOK_INIT(locked_down, lockdown_is_locked_down), > }; > > +static struct lsm_id lockdown_lsmid __lsm_ro_after_init = { > + .lsm = "lockdown", > + .slot = LSMBLOB_NOT_NEEDED > +}; > + > static int __init lockdown_lsm_init(void) > { > #if defined(CONFIG_LOCK_DOWN_KERNEL_FORCE_INTEGRITY) > @@ -83,7 +88,7 @@ static int __init lockdown_lsm_init(void) > lock_kernel_down("Kernel configuration", LOCKDOWN_CONFIDENTIALITY_MAX); > #endif > security_add_hooks(lockdown_hooks, ARRAY_SIZE(lockdown_hooks), > - "lockdown"); > + &lockdown_lsmid); > return 0; > } > > diff --git a/security/safesetid/lsm.c b/security/safesetid/lsm.c > index 963f4ad9cb66..0c368950dc14 100644 > --- a/security/safesetid/lsm.c > +++ b/security/safesetid/lsm.c > @@ -241,6 +241,11 @@ static int safesetid_task_fix_setgid(struct cred *new, > return -EACCES; > } > > +static struct lsm_id safesetid_lsmid __lsm_ro_after_init = { > + .lsm = "safesetid", > + .slot = LSMBLOB_NOT_NEEDED > +}; > + > static struct security_hook_list safesetid_security_hooks[] = { > LSM_HOOK_INIT(task_fix_setuid, safesetid_task_fix_setuid), > LSM_HOOK_INIT(task_fix_setgid, safesetid_task_fix_setgid), > @@ -250,7 +255,8 @@ static struct security_hook_list safesetid_security_hooks[] = { > static int __init safesetid_security_init(void) > { > security_add_hooks(safesetid_security_hooks, > - ARRAY_SIZE(safesetid_security_hooks), "safesetid"); > + ARRAY_SIZE(safesetid_security_hooks), > + &safesetid_lsmid); > > /* Report that SafeSetID successfully initialized */ > safesetid_initialized = 1; > diff --git a/security/security.c b/security/security.c > index f2d4b20613c8..2bf21c726ba0 100644 > --- a/security/security.c > +++ b/security/security.c > @@ -345,6 +345,7 @@ static void __init ordered_lsm_init(void) > init_debug("sock blob size = %d\n", blob_sizes.lbs_sock); > init_debug("superblock blob size = %d\n", blob_sizes.lbs_superblock); > init_debug("task blob size = %d\n", blob_sizes.lbs_task); > + init_debug("lsmblob size = %zu\n", sizeof(struct lsmblob)); > > /* > * Create any kmem_caches needed for blobs > @@ -472,21 +473,38 @@ static int lsm_append(const char *new, char **result) > return 0; > } > > +/* > + * Current index to use while initializing the lsmblob secid list. > + */ > +static int lsm_slot __lsm_ro_after_init; > + > /** > * security_add_hooks - Add a modules hooks to the hook lists. > * @hooks: the hooks to add > * @count: the number of hooks to add > - * @lsm: the name of the security module > + * @lsmid: the identification information for the security module > * > * Each LSM has to register its hooks with the infrastructure. > + * If the LSM is using hooks that export secids allocate a slot > + * for it in the lsmblob. > */ > void __init security_add_hooks(struct security_hook_list *hooks, int count, > - char *lsm) > + struct lsm_id *lsmid) > { > int i; > > + WARN_ON(!lsmid->slot || !lsmid->lsm); > + > + if (lsmid->slot == LSMBLOB_NEEDED) { > + if (lsm_slot >= LSMBLOB_ENTRIES) > + panic("%s Too many LSMs registered.\n", __func__); > + lsmid->slot = lsm_slot++; > + init_debug("%s assigned lsmblob slot %d\n", lsmid->lsm, > + lsmid->slot); > + } > + > for (i = 0; i < count; i++) { > - hooks[i].lsm = lsm; > + hooks[i].lsmid = lsmid; > hlist_add_tail_rcu(&hooks[i].list, hooks[i].head); > } > > @@ -495,7 +513,7 @@ void __init security_add_hooks(struct security_hook_list *hooks, int count, > * and fix this up afterwards. > */ > if (slab_is_available()) { > - if (lsm_append(lsm, &lsm_names) < 0) > + if (lsm_append(lsmid->lsm, &lsm_names) < 0) > panic("%s - Cannot get early memory.\n", __func__); > } > } > @@ -2075,7 +2093,7 @@ int security_getprocattr(struct task_struct *p, const char *lsm, char *name, > struct security_hook_list *hp; > > hlist_for_each_entry(hp, &security_hook_heads.getprocattr, list) { > - if (lsm != NULL && strcmp(lsm, hp->lsm)) > + if (lsm != NULL && strcmp(lsm, hp->lsmid->lsm)) > continue; > return hp->hook.getprocattr(p, name, value); > } > @@ -2088,7 +2106,7 @@ int security_setprocattr(const char *lsm, const char *name, void *value, > struct security_hook_list *hp; > > hlist_for_each_entry(hp, &security_hook_heads.setprocattr, list) { > - if (lsm != NULL && strcmp(lsm, hp->lsm)) > + if (lsm != NULL && strcmp(lsm, hp->lsmid->lsm)) > continue; > return hp->hook.setprocattr(name, value, size); > } > @@ -2579,9 +2597,27 @@ int security_key_getsecurity(struct key *key, char **_buffer) > > #ifdef CONFIG_AUDIT > > -int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule) > +int security_audit_rule_init(u32 field, u32 op, char *rulestr, > + struct audit_lsm_rules *lsmrules) > { > - return call_int_hook(audit_rule_init, 0, field, op, rulestr, lsmrule); > + struct security_hook_list *hp; > + bool one_is_good = false; > + int rc = 0; > + int trc; > + > + hlist_for_each_entry(hp, &security_hook_heads.audit_rule_init, list) { > + if (WARN_ON(hp->lsmid->slot < 0 || hp->lsmid->slot >= lsm_slot)) > + continue; > + trc = hp->hook.audit_rule_init(field, op, rulestr, > + &lsmrules->rule[hp->lsmid->slot]); > + if (trc == 0) > + one_is_good = true; > + else > + rc = trc; > + } > + if (one_is_good) > + return 0; > + return rc; > } > > int security_audit_rule_known(struct audit_krule *krule) > @@ -2589,14 +2625,36 @@ int security_audit_rule_known(struct audit_krule *krule) > return call_int_hook(audit_rule_known, 0, krule); > } > > -void security_audit_rule_free(void *lsmrule) > +void security_audit_rule_free(struct audit_lsm_rules *lsmrules) > { > - call_void_hook(audit_rule_free, lsmrule); > + struct security_hook_list *hp; > + > + hlist_for_each_entry(hp, &security_hook_heads.audit_rule_free, list) { > + if (WARN_ON(hp->lsmid->slot < 0 || hp->lsmid->slot >= lsm_slot)) > + continue; > + if (lsmrules->rule[hp->lsmid->slot] == NULL) > + continue; > + hp->hook.audit_rule_free(lsmrules->rule[hp->lsmid->slot]); > + } > } > > -int security_audit_rule_match(u32 secid, u32 field, u32 op, void *lsmrule) > +int security_audit_rule_match(u32 secid, u32 field, u32 op, > + struct audit_lsm_rules *lsmrules) > { > - return call_int_hook(audit_rule_match, 0, secid, field, op, lsmrule); > + struct security_hook_list *hp; > + int rc; > + > + hlist_for_each_entry(hp, &security_hook_heads.audit_rule_match, list) { > + if (WARN_ON(hp->lsmid->slot < 0 || hp->lsmid->slot >= lsm_slot)) > + continue; > + if (lsmrules->rule[hp->lsmid->slot] == NULL) > + continue; > + rc = hp->hook.audit_rule_match(secid, field, op, > + &lsmrules->rule[hp->lsmid->slot]); > + if (rc) > + return rc; > + } > + return 0; > } > #endif /* CONFIG_AUDIT */ > > diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c > index dffde40d367e..d67bcd1aeaf5 100644 > --- a/security/selinux/hooks.c > +++ b/security/selinux/hooks.c > @@ -7009,6 +7009,11 @@ static int selinux_uring_sqpoll(void) > } > #endif /* CONFIG_IO_URING */ > > +static struct lsm_id selinux_lsmid __lsm_ro_after_init = { > + .lsm = "selinux", > + .slot = LSMBLOB_NEEDED > +}; > + > /* > * IMPORTANT NOTE: When adding new hooks, please be careful to keep this order: > * 1. any hooks that don't belong to (2.) or (3.) below, > @@ -7324,7 +7329,8 @@ static __init int selinux_init(void) > > hashtab_cache_init(); > > - security_add_hooks(selinux_hooks, ARRAY_SIZE(selinux_hooks), "selinux"); > + security_add_hooks(selinux_hooks, ARRAY_SIZE(selinux_hooks), > + &selinux_lsmid); > > if (avc_add_callback(selinux_netcache_avc_callback, AVC_CALLBACK_RESET)) > panic("SELinux: Unable to register AVC netcache callback\n"); > diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c > index d58b50006e79..ff832d47479f 100644 > --- a/security/smack/smack_lsm.c > +++ b/security/smack/smack_lsm.c > @@ -4744,6 +4744,11 @@ struct lsm_blob_sizes smack_blob_sizes __lsm_ro_after_init = { > .lbs_superblock = sizeof(struct superblock_smack), > }; > > +static struct lsm_id smack_lsmid __lsm_ro_after_init = { > + .lsm = "smack", > + .slot = LSMBLOB_NEEDED > +}; > + > static struct security_hook_list smack_hooks[] __lsm_ro_after_init = { > LSM_HOOK_INIT(ptrace_access_check, smack_ptrace_access_check), > LSM_HOOK_INIT(ptrace_traceme, smack_ptrace_traceme), > @@ -4947,7 +4952,7 @@ static __init int smack_init(void) > /* > * Register with LSM > */ > - security_add_hooks(smack_hooks, ARRAY_SIZE(smack_hooks), "smack"); > + security_add_hooks(smack_hooks, ARRAY_SIZE(smack_hooks), &smack_lsmid); > smack_enabled = 1; > > pr_info("Smack: Initializing.\n"); > diff --git a/security/tomoyo/tomoyo.c b/security/tomoyo/tomoyo.c > index b6a31901f289..e8f6bb9782c1 100644 > --- a/security/tomoyo/tomoyo.c > +++ b/security/tomoyo/tomoyo.c > @@ -521,6 +521,11 @@ static void tomoyo_task_free(struct task_struct *task) > } > } > > +static struct lsm_id tomoyo_lsmid __lsm_ro_after_init = { > + .lsm = "tomoyo", > + .slot = LSMBLOB_NOT_NEEDED > +}; > + > /* > * tomoyo_security_ops is a "struct security_operations" which is used for > * registering TOMOYO. > @@ -573,7 +578,8 @@ static int __init tomoyo_init(void) > struct tomoyo_task *s = tomoyo_task(current); > > /* register ourselves with the security framework */ > - security_add_hooks(tomoyo_hooks, ARRAY_SIZE(tomoyo_hooks), "tomoyo"); > + security_add_hooks(tomoyo_hooks, ARRAY_SIZE(tomoyo_hooks), > + &tomoyo_lsmid); > pr_info("TOMOYO Linux initialized\n"); > s->domain_info = &tomoyo_kernel_domain; > atomic_inc(&tomoyo_kernel_domain.users); > diff --git a/security/yama/yama_lsm.c b/security/yama/yama_lsm.c > index 06e226166aab..a9639ea541f7 100644 > --- a/security/yama/yama_lsm.c > +++ b/security/yama/yama_lsm.c > @@ -421,6 +421,11 @@ static int yama_ptrace_traceme(struct task_struct *parent) > return rc; > } > > +static struct lsm_id yama_lsmid __lsm_ro_after_init = { > + .lsm = "yama", > + .slot = LSMBLOB_NOT_NEEDED > +}; > + > static struct security_hook_list yama_hooks[] __lsm_ro_after_init = { > LSM_HOOK_INIT(ptrace_access_check, yama_ptrace_access_check), > LSM_HOOK_INIT(ptrace_traceme, yama_ptrace_traceme), > @@ -477,7 +482,7 @@ static inline void yama_init_sysctl(void) { } > static int __init yama_init(void) > { > pr_info("Yama: becoming mindful.\n"); > - security_add_hooks(yama_hooks, ARRAY_SIZE(yama_hooks), "yama"); > + security_add_hooks(yama_hooks, ARRAY_SIZE(yama_hooks), &yama_lsmid); > yama_init_sysctl(); > return 0; > } From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id B8000C433F5 for ; Fri, 4 Mar 2022 13:17:15 +0000 (UTC) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-315-YeSq7ltFP1anJKo6kyWeVA-1; Fri, 04 Mar 2022 08:17:11 -0500 X-MC-Unique: YeSq7ltFP1anJKo6kyWeVA-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 8AF86824FAB; Fri, 4 Mar 2022 13:17:07 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id B8B197DE40; Fri, 4 Mar 2022 13:17:04 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id BAF9C37A0; Fri, 4 Mar 2022 13:17:01 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.rdu2.redhat.com [10.11.54.7]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 224B6mTp025616 for ; Fri, 4 Mar 2022 06:06:48 -0500 Received: by smtp.corp.redhat.com (Postfix) id 6B439141DEDC; Fri, 4 Mar 2022 11:06:48 +0000 (UTC) Received: from mimecast-mx02.redhat.com (mimecast03.extmail.prod.ext.rdu2.redhat.com [10.11.55.19]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 66AAC140240B for ; Fri, 4 Mar 2022 11:06:48 +0000 (UTC) Received: from us-smtp-1.mimecast.com (us-smtp-delivery-1.mimecast.com [207.211.31.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 12E91811E7A for ; Fri, 4 Mar 2022 11:06:48 +0000 (UTC) Received: from smtp-42a8.mail.infomaniak.ch (smtp-42a8.mail.infomaniak.ch [84.16.66.168]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-397-pozlyEonPw-yk-LdRjpUVA-1; Fri, 04 Mar 2022 06:06:46 -0500 X-MC-Unique: pozlyEonPw-yk-LdRjpUVA-1 Received: from smtp-3-0001.mail.infomaniak.ch (unknown [10.4.36.108]) by smtp-3-3000.mail.infomaniak.ch (Postfix) with ESMTPS id 4K94N55qFQzMqLlC; Fri, 4 Mar 2022 11:48:53 +0100 (CET) Received: from ns3096276.ip-94-23-54.eu (unknown [23.97.221.149]) by smtp-3-0001.mail.infomaniak.ch (Postfix) with ESMTPA id 4K94N347yKzlhMC7; Fri, 4 Mar 2022 11:48:51 +0100 (CET) Message-ID: Date: Fri, 4 Mar 2022 11:48:58 +0100 MIME-Version: 1.0 User-Agent: To: Casey Schaufler , casey.schaufler@intel.com, jmorris@namei.org, linux-security-module@vger.kernel.org, selinux@vger.kernel.org References: <20220202235323.23929-1-casey@schaufler-ca.com> <20220202235323.23929-4-casey@schaufler-ca.com> From: =?UTF-8?Q?Micka=c3=abl_Sala=c3=bcn?= Subject: Re: [PATCH v32 03/28] LSM: Add the lsmblob data structure. In-Reply-To: <20220202235323.23929-4-casey@schaufler-ca.com> X-Mimecast-Impersonation-Protect: Policy=CLT - Impersonation Protection Definition; Similar Internal Domain=false; Similar Monitored External Domain=false; Custom External Domain=false; Mimecast External Domain=false; Newly Observed Domain=false; Internal User Name=false; Custom Display Name List=false; Reply-to Address Mismatch=false; Targeted Threat Dictionary=false; Mimecast Threat Dictionary=false; Custom Threat Dictionary=false X-Scanned-By: MIMEDefang 2.85 on 10.11.54.7 X-MIME-Autoconverted: from quoted-printable to 8bit by lists01.pubmisc.prod.ext.phx2.redhat.com id 224B6mTp025616 X-loop: linux-audit@redhat.com X-Mailman-Approved-At: Fri, 04 Mar 2022 08:16:59 -0500 Cc: john.johansen@canonical.com, linux-kernel@vger.kernel.org, linux-audit@redhat.com, sds@tycho.nsa.gov X-BeenThere: linux-audit@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Linux Audit Discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: linux-audit-bounces@redhat.com Errors-To: linux-audit-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=linux-audit-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-US Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Ck9uIDAzLzAyLzIwMjIgMDA6NTIsIENhc2V5IFNjaGF1ZmxlciB3cm90ZToKPiBXaGVuIG1vcmUg dGhhbiBvbmUgc2VjdXJpdHkgbW9kdWxlIGlzIGV4cG9ydGluZyBkYXRhIHRvCj4gYXVkaXQgYW5k IG5ldHdvcmtpbmcgc3ViLXN5c3RlbXMgYSBzaW5nbGUgMzIgYml0IGludGVnZXIKPiBpcyBubyBs b25nZXIgc3VmZmljaWVudCB0byByZXByZXNlbnQgdGhlIGRhdGEuIEFkZCBhCj4gc3RydWN0dXJl IHRvIGJlIHVzZWQgaW5zdGVhZC4KPiAKPiBUaGUgbHNtYmxvYiBzdHJ1Y3R1cmUgaXMgY3VycmVu dGx5IGFuIGFycmF5IG9mCj4gdTMyICJzZWNpZHMiLiBUaGVyZSBpcyBhbiBlbnRyeSBmb3IgZWFj aCBvZiB0aGUKPiBzZWN1cml0eSBtb2R1bGVzIGJ1aWx0IGludG8gdGhlIHN5c3RlbSB0aGF0IHdv dWxkCj4gdXNlIHNlY2lkcyBpZiBhY3RpdmUuIFRoZSBzeXN0ZW0gYXNzaWducyB0aGUgbW9kdWxl Cj4gYSAic2xvdCIgd2hlbiBpdCByZWdpc3RlcnMgaG9va3MuIElmIG1vZHVsZXMgYXJlCj4gY29t cGlsZWQgaW4gYnV0IG5vdCByZWdpc3RlcmVkIHRoZXJlIHdpbGwgYmUgdW51c2VkCj4gc2xvdHMu Cj4gCj4gQSBuZXcgbHNtX2lkIHN0cnVjdHVyZSwgd2hpY2ggY29udGFpbnMgdGhlIG5hbWUKPiBv ZiB0aGUgTFNNIGFuZCBpdHMgc2xvdCBudW1iZXIsIGlzIGNyZWF0ZWQuIFRoZXJlCj4gaXMgYW4g aW5zdGFuY2UgZm9yIGVhY2ggTFNNLCB3aGljaCBhc3NpZ25zIHRoZSBuYW1lCj4gYW5kIHBhc3Nl cyBpdCB0byB0aGUgaW5mcmFzdHJ1Y3R1cmUgdG8gc2V0IHRoZSBzbG90Lgo+IAo+IFRoZSBhdWRp dCBydWxlcyBkYXRhIGlzIGV4cGFuZGVkIHRvIHVzZSBhbiBhcnJheSBvZgo+IHNlY3VyaXR5IG1v ZHVsZSBkYXRhIHJhdGhlciB0aGFuIGEgc2luZ2xlIGluc3RhbmNlLgo+IEEgbmV3IHN0cnVjdHVy ZSBhdWRpdF9sc21fcnVsZXMgaXMgZGVmaW5lZCB0byBhdm9pZCB0aGUKPiBjb25mdXNpb24gd2hp Y2ggY29tbW9ubHkgYWNjb21wYW5pZXMgdGhlIHVzZSBvZgo+IHZvaWQgKiogcGFyYW1ldGVycy4K PiAKPiBTaWduZWQtb2ZmLWJ5OiBDYXNleSBTY2hhdWZsZXIgPGNhc2V5QHNjaGF1Zmxlci1jYS5j b20+CgpSZXZpZXdlZC1ieTogTWlja2HDq2wgU2FsYcO8biA8bWljQGxpbnV4Lm1pY3Jvc29mdC5j b20+CgoKTWlub3IgZml4ZXM6CgoKPiAtLS0KPiAgIGluY2x1ZGUvbGludXgvYXVkaXQuaCAgICAg ICAgfCAxMCArKysrLQo+ICAgaW5jbHVkZS9saW51eC9sc21faG9va3MuaCAgICB8IDEyICsrKysr LQo+ICAgaW5jbHVkZS9saW51eC9zZWN1cml0eS5oICAgICB8IDc0ICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrLS0tCj4gICBrZXJuZWwvYXVkaXRmaWx0ZXIuYyAgICAgICAgIHwgMjMgKysr KystLS0tLQo+ICAga2VybmVsL2F1ZGl0c2MuYyAgICAgICAgICAgICB8IDE3ICsrKy0tLS0tCj4g ICBzZWN1cml0eS9hcHBhcm1vci9sc20uYyAgICAgIHwgIDcgKystCj4gICBzZWN1cml0eS9icGYv aG9va3MuYyAgICAgICAgIHwgMTIgKysrKystCj4gICBzZWN1cml0eS9jb21tb25jYXAuYyAgICAg ICAgIHwgIDcgKystCj4gICBzZWN1cml0eS9sYW5kbG9jay9jcmVkLmMgICAgIHwgIDIgKy0KPiAg IHNlY3VyaXR5L2xhbmRsb2NrL2ZzLmMgICAgICAgfCAgMiArLQo+ICAgc2VjdXJpdHkvbGFuZGxv Y2svcHRyYWNlLmMgICB8ICAyICstCj4gICBzZWN1cml0eS9sYW5kbG9jay9zZXR1cC5jICAgIHwg IDUgKysrCj4gICBzZWN1cml0eS9sYW5kbG9jay9zZXR1cC5oICAgIHwgIDEgKwo+ICAgc2VjdXJp dHkvbG9hZHBpbi9sb2FkcGluLmMgICB8ICA4ICsrKy0KPiAgIHNlY3VyaXR5L2xvY2tkb3duL2xv Y2tkb3duLmMgfCAgNyArKy0KPiAgIHNlY3VyaXR5L3NhZmVzZXRpZC9sc20uYyAgICAgfCAgOCAr KystCj4gICBzZWN1cml0eS9zZWN1cml0eS5jICAgICAgICAgIHwgODIgKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrLS0tLS0tCj4gICBzZWN1cml0eS9zZWxpbnV4L2hvb2tzLmMgICAgIHwg IDggKysrLQo+ICAgc2VjdXJpdHkvc21hY2svc21hY2tfbHNtLmMgICB8ICA3ICsrLQo+ICAgc2Vj dXJpdHkvdG9tb3lvL3RvbW95by5jICAgICB8ICA4ICsrKy0KPiAgIHNlY3VyaXR5L3lhbWEveWFt YV9sc20uYyAgICAgfCAgNyArKy0KPiAgIDIxIGZpbGVzIGNoYW5nZWQsIDI1MyBpbnNlcnRpb25z KCspLCA1NiBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9hdWRp dC5oIGIvaW5jbHVkZS9saW51eC9hdWRpdC5oCj4gaW5kZXggZDA2MTM0YWM2MjQ1Li4xNDg0OWQ1 Zjg0YjQgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9saW51eC9hdWRpdC5oCj4gKysrIGIvaW5jbHVk ZS9saW51eC9hdWRpdC5oCj4gQEAgLTExLDYgKzExLDcgQEAKPiAgIAo+ICAgI2luY2x1ZGUgPGxp bnV4L3NjaGVkLmg+Cj4gICAjaW5jbHVkZSA8bGludXgvcHRyYWNlLmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9zZWN1cml0eS5oPgo+ICAgI2luY2x1ZGUgPGxpbnV4L2F1ZGl0X2FyY2guaD4KPiAgICNp bmNsdWRlIDx1YXBpL2xpbnV4L2F1ZGl0Lmg+Cj4gICAjaW5jbHVkZSA8dWFwaS9saW51eC9uZXRm aWx0ZXIvbmZfdGFibGVzLmg+Cj4gQEAgLTU5LDYgKzYwLDEwIEBAIHN0cnVjdCBhdWRpdF9rcnVs ZSB7Cj4gICAvKiBGbGFnIHRvIGluZGljYXRlIGxlZ2FjeSBBVURJVF9MT0dJTlVJRCB1bnNldCB1 c2FnZSAqLwo+ICAgI2RlZmluZSBBVURJVF9MT0dJTlVJRF9MRUdBQ1kJCTB4MQo+ICAgCj4gK3N0 cnVjdCBhdWRpdF9sc21fcnVsZXMgewo+ICsJdm9pZAkqcnVsZVtMU01CTE9CX0VOVFJJRVNdOwo+ ICt9Owo+ICsKPiAgIHN0cnVjdCBhdWRpdF9maWVsZCB7Cj4gICAJdTMyCQkJCXR5cGU7Cj4gICAJ dW5pb24gewo+IEBAIC02Niw4ICs3MSw5IEBAIHN0cnVjdCBhdWRpdF9maWVsZCB7Cj4gICAJCWt1 aWRfdAkJCXVpZDsKPiAgIAkJa2dpZF90CQkJZ2lkOwo+ICAgCQlzdHJ1Y3Qgewo+IC0JCQljaGFy CQkqbHNtX3N0cjsKPiAtCQkJdm9pZAkJKmxzbV9ydWxlOwo+ICsJCQlib29sCQkJbHNtX2lzc2V0 Owo+ICsJCQljaGFyCQkJKmxzbV9zdHI7Cj4gKwkJCXN0cnVjdCBhdWRpdF9sc21fcnVsZXMJbHNt X3J1bGVzOwo+ICAgCQl9Owo+ICAgCX07Cj4gICAJdTMyCQkJCW9wOwo+IGRpZmYgLS1naXQgYS9p bmNsdWRlL2xpbnV4L2xzbV9ob29rcy5oIGIvaW5jbHVkZS9saW51eC9sc21faG9va3MuaAo+IGlu ZGV4IDEyOWQ5OWM2ZjllZC4uMmMyZDBlZjU5YTQxIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbGlu dXgvbHNtX2hvb2tzLmgKPiArKysgYi9pbmNsdWRlL2xpbnV4L2xzbV9ob29rcy5oCj4gQEAgLTE1 ODIsNiArMTU4MiwxNCBAQCBzdHJ1Y3Qgc2VjdXJpdHlfaG9va19oZWFkcyB7Cj4gICAJI3VuZGVm IExTTV9IT09LCj4gICB9IF9fcmFuZG9taXplX2xheW91dDsKPiAgIAo+ICsvKgo+ICsgKiBJbmZv cm1hdGlvbiB0aGF0IGlkZW50aWZpZXMgYSBzZWN1cml0eSBtb2R1bGUuCj4gKyAqLwo+ICtzdHJ1 Y3QgbHNtX2lkIHsKPiArCWNvbnN0IGNoYXIJKmxzbTsJLyogTmFtZSBvZiB0aGUgTFNNICovCj4g KwlpbnQJCXNsb3Q7CS8qIFNsb3QgaW4gbHNtYmxvYiBpZiBvbmUgaXMgYWxsb2NhdGVkICovCj4g K307Cj4gKwo+ICAgLyoKPiAgICAqIFNlY3VyaXR5IG1vZHVsZSBob29rIGxpc3Qgc3RydWN0dXJl Lgo+ICAgICogRm9yIHVzZSB3aXRoIGdlbmVyaWMgbGlzdCBtYWNyb3MgZm9yIGNvbW1vbiBvcGVy YXRpb25zLgo+IEBAIC0xNTkwLDcgKzE1OTgsNyBAQCBzdHJ1Y3Qgc2VjdXJpdHlfaG9va19saXN0 IHsKPiAgIAlzdHJ1Y3QgaGxpc3Rfbm9kZQkJbGlzdDsKPiAgIAlzdHJ1Y3QgaGxpc3RfaGVhZAkJ KmhlYWQ7Cj4gICAJdW5pb24gc2VjdXJpdHlfbGlzdF9vcHRpb25zCWhvb2s7Cj4gLQljaGFyCQkJ CSpsc207Cj4gKwlzdHJ1Y3QgbHNtX2lkCQkJKmxzbWlkOwo+ICAgfSBfX3JhbmRvbWl6ZV9sYXlv dXQ7Cj4gICAKPiAgIC8qCj4gQEAgLTE2MjYsNyArMTYzNCw3IEBAIGV4dGVybiBzdHJ1Y3Qgc2Vj dXJpdHlfaG9va19oZWFkcyBzZWN1cml0eV9ob29rX2hlYWRzOwo+ICAgZXh0ZXJuIGNoYXIgKmxz bV9uYW1lczsKPiAgIAo+ICAgZXh0ZXJuIHZvaWQgc2VjdXJpdHlfYWRkX2hvb2tzKHN0cnVjdCBz ZWN1cml0eV9ob29rX2xpc3QgKmhvb2tzLCBpbnQgY291bnQsCj4gLQkJCQljaGFyICpsc20pOwo+ ICsJCQkgICAgICAgc3RydWN0IGxzbV9pZCAqbHNtaWQpOwo+ICAgCj4gICAjZGVmaW5lIExTTV9G TEFHX0xFR0FDWV9NQUpPUglCSVQoMCkKPiAgICNkZWZpbmUgTFNNX0ZMQUdfRVhDTFVTSVZFCUJJ VCgxKQo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3NlY3VyaXR5LmggYi9pbmNsdWRlL2xp bnV4L3NlY3VyaXR5LmgKPiBpbmRleCAzM2UwZjJlNjU5ZGYuLjFhN2U1YmYzNmE4MiAxMDA2NDQK PiAtLS0gYS9pbmNsdWRlL2xpbnV4L3NlY3VyaXR5LmgKPiArKysgYi9pbmNsdWRlL2xpbnV4L3Nl Y3VyaXR5LmgKPiBAQCAtMzksNiArMzksNyBAQCBzdHJ1Y3Qga2VybmVsX3NpZ2luZm87Cj4gICBz dHJ1Y3Qgc2VtYnVmOwo+ICAgc3RydWN0IGtlcm5faXBjX3Blcm07Cj4gICBzdHJ1Y3QgYXVkaXRf Y29udGV4dDsKPiArc3RydWN0IGF1ZGl0X2xzbV9ydWxlczsKPiAgIHN0cnVjdCBzdXBlcl9ibG9j azsKPiAgIHN0cnVjdCBpbm9kZTsKPiAgIHN0cnVjdCBkZW50cnk7Cj4gQEAgLTEzNCw2ICsxMzUs NjUgQEAgZW51bSBsb2NrZG93bl9yZWFzb24gewo+ICAgCj4gICBleHRlcm4gY29uc3QgY2hhciAq Y29uc3QgbG9ja2Rvd25fcmVhc29uc1tMT0NLRE9XTl9DT05GSURFTlRJQUxJVFlfTUFYKzFdOwo+ ICAgCj4gKy8qCj4gKyAqIERhdGEgZXhwb3J0ZWQgYnkgdGhlIHNlY3VyaXR5IG1vZHVsZXMKPiAr ICoKPiArICogQW55IExTTSB0aGF0IHByb3ZpZGVzIHNlY2lkIG9yIHNlY2N0eCBiYXNlZCBob29r cyBtdXN0IGJlIGluY2x1ZGVkLgo+ICsgKi8KPiArI2RlZmluZSBMU01CTE9CX0VOVFJJRVMgKCBc Cj4gKwkoSVNfRU5BQkxFRChDT05GSUdfU0VDVVJJVFlfU0VMSU5VWCkgPyAxIDogMCkgKyBcCj4g KwkoSVNfRU5BQkxFRChDT05GSUdfU0VDVVJJVFlfU01BQ0spID8gMSA6IDApICsgXAo+ICsJKElT X0VOQUJMRUQoQ09ORklHX1NFQ1VSSVRZX0FQUEFSTU9SKSA/IDEgOiAwKSArIFwKPiArCShJU19F TkFCTEVEKENPTkZJR19CUEZfTFNNKSA/IDEgOiAwKSkKPiArCj4gK3N0cnVjdCBsc21ibG9iIHsK PiArCXUzMiAgICAgc2VjaWRbTFNNQkxPQl9FTlRSSUVTXTsKPiArfTsKPiArCj4gKyNkZWZpbmUg TFNNQkxPQl9JTlZBTElECQktMQkvKiBOb3QgYSB2YWxpZCBMU00gc2xvdCBudW1iZXIgKi8KPiAr I2RlZmluZSBMU01CTE9CX05FRURFRAkJLTIJLyogU2xvdCByZXF1ZXN0ZWQgb24gaW5pdGlhbGl6 YXRpb24gKi8KPiArI2RlZmluZSBMU01CTE9CX05PVF9ORUVERUQJLTMJLyogU2xvdCBub3QgcmVx dWVzdGVkICovCj4gKwo+ICsvKioKPiArICogbHNtYmxvYl9pbml0IC0gaW5pdGlhbGl6ZSBhbiBs c21ibG9iIHN0cnVjdHVyZQo+ICsgKiBAYmxvYjogUG9pbnRlciB0byB0aGUgZGF0YSB0byBpbml0 aWFsaXplCj4gKyAqIEBzZWNpZDogVGhlIGluaXRpYWwgc2VjaWQgdmFsdWUKPiArICoKPiArICog U2V0IGFsbCBzZWNpZCBmb3IgYWxsIG1vZHVsZXMgdG8gdGhlIHNwZWNpZmllZCB2YWx1ZS4KPiAr ICovCj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBsc21ibG9iX2luaXQoc3RydWN0IGxzbWJsb2IgKmJs b2IsIHUzMiBzZWNpZCkKPiArewo+ICsJaW50IGk7Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IExT TUJMT0JfRU5UUklFUzsgaSsrKQo+ICsJCWJsb2ItPnNlY2lkW2ldID0gc2VjaWQ7Cj4gK30KPiAr Cj4gKy8qKgo+ICsgKiBsc21ibG9iX2lzX3NldCAtIHJlcG9ydCBpZiB0aGVyZSBpcyBhbiB2YWx1 ZSBpbiB0aGUgbHNtYmxvYgoKKmEqIHZhbHVlCgoKPiArICogQGJsb2I6IFBvaW50ZXIgdG8gdGhl IGV4cG9ydGVkIExTTSBkYXRhCj4gKyAqCj4gKyAqIFJldHVybnMgdHJ1ZSBpZiB0aGVyZSBpcyBh IHNlY2lkIHNldCwgZmFsc2Ugb3RoZXJ3aXNlCj4gKyAqLwo+ICtzdGF0aWMgaW5saW5lIGJvb2wg bHNtYmxvYl9pc19zZXQoc3RydWN0IGxzbWJsb2IgKmJsb2IpCj4gK3sKPiArCXN0cnVjdCBsc21i bG9iIGVtcHR5ID0ge307Cgpjb25zdCBzdHJ1Y3QgbHNtYmxvYiBlbXB0eSA9IHt9OwoKPiArCj4g KwlyZXR1cm4gISFtZW1jbXAoYmxvYiwgJmVtcHR5LCBzaXplb2YoKmJsb2IpKTsKPiArfQo+ICsK PiArLyoqCj4gKyAqIGxzbWJsb2JfZXF1YWwgLSByZXBvcnQgaWYgdGhlIHR3byBsc21ibG9iJ3Mg YXJlIGVxdWFsCj4gKyAqIEBibG9iYTogUG9pbnRlciB0byBvbmUgTFNNIGRhdGEKPiArICogQGJs b2JiOiBQb2ludGVyIHRvIHRoZSBvdGhlciBMU00gZGF0YQo+ICsgKgo+ICsgKiBSZXR1cm5zIHRy dWUgaWYgYWxsIGVudHJpZXMgaW4gdGhlIHR3byBhcmUgZXF1YWwsIGZhbHNlIG90aGVyd2lzZQo+ ICsgKi8KPiArc3RhdGljIGlubGluZSBib29sIGxzbWJsb2JfZXF1YWwoc3RydWN0IGxzbWJsb2Ig KmJsb2JhLCBzdHJ1Y3QgbHNtYmxvYiAqYmxvYmIpCgpjb25zdCBzdHJ1Y3QgbHNtYmxvYiAqYmxv YmEsIGNvbnN0IHN0cnVjdCBsc21ibG9iICpibG9iYgoKCj4gK3sKPiArCXJldHVybiAhbWVtY21w KGJsb2JhLCBibG9iYiwgc2l6ZW9mKCpibG9iYSkpOwo+ICt9Cj4gKwo+ICAgLyogVGhlc2UgZnVu Y3Rpb25zIGFyZSBpbiBzZWN1cml0eS9jb21tb25jYXAuYyAqLwo+ICAgZXh0ZXJuIGludCBjYXBf Y2FwYWJsZShjb25zdCBzdHJ1Y3QgY3JlZCAqY3JlZCwgc3RydWN0IHVzZXJfbmFtZXNwYWNlICpu cywKPiAgIAkJICAgICAgIGludCBjYXAsIHVuc2lnbmVkIGludCBvcHRzKTsKPiBAQCAtMTg3OSwx NSArMTkzOSwxNyBAQCBzdGF0aWMgaW5saW5lIGludCBzZWN1cml0eV9rZXlfZ2V0c2VjdXJpdHko c3RydWN0IGtleSAqa2V5LCBjaGFyICoqX2J1ZmZlcikKPiAgIAo+ICAgI2lmZGVmIENPTkZJR19B VURJVAo+ICAgI2lmZGVmIENPTkZJR19TRUNVUklUWQo+IC1pbnQgc2VjdXJpdHlfYXVkaXRfcnVs ZV9pbml0KHUzMiBmaWVsZCwgdTMyIG9wLCBjaGFyICpydWxlc3RyLCB2b2lkICoqbHNtcnVsZSk7 Cj4gK2ludCBzZWN1cml0eV9hdWRpdF9ydWxlX2luaXQodTMyIGZpZWxkLCB1MzIgb3AsIGNoYXIg KnJ1bGVzdHIsCj4gKwkJCSAgICAgc3RydWN0IGF1ZGl0X2xzbV9ydWxlcyAqbHNtcnVsZXMpOwo+ ICAgaW50IHNlY3VyaXR5X2F1ZGl0X3J1bGVfa25vd24oc3RydWN0IGF1ZGl0X2tydWxlICprcnVs ZSk7Cj4gLWludCBzZWN1cml0eV9hdWRpdF9ydWxlX21hdGNoKHUzMiBzZWNpZCwgdTMyIGZpZWxk LCB1MzIgb3AsIHZvaWQgKmxzbXJ1bGUpOwo+IC12b2lkIHNlY3VyaXR5X2F1ZGl0X3J1bGVfZnJl ZSh2b2lkICpsc21ydWxlKTsKPiAraW50IHNlY3VyaXR5X2F1ZGl0X3J1bGVfbWF0Y2godTMyIHNl Y2lkLCB1MzIgZmllbGQsIHUzMiBvcCwKPiArCQkJICAgICAgc3RydWN0IGF1ZGl0X2xzbV9ydWxl cyAqbHNtcnVsZXMpOwo+ICt2b2lkIHNlY3VyaXR5X2F1ZGl0X3J1bGVfZnJlZShzdHJ1Y3QgYXVk aXRfbHNtX3J1bGVzICpsc21ydWxlcyk7Cj4gICAKPiAgICNlbHNlCj4gICAKPiAgIHN0YXRpYyBp bmxpbmUgaW50IHNlY3VyaXR5X2F1ZGl0X3J1bGVfaW5pdCh1MzIgZmllbGQsIHUzMiBvcCwgY2hh ciAqcnVsZXN0ciwKPiAtCQkJCQkgICB2b2lkICoqbHNtcnVsZSkKPiArCQkJCQkgICBzdHJ1Y3Qg YXVkaXRfbHNtX3J1bGVzICpsc21ydWxlcykKPiAgIHsKPiAgIAlyZXR1cm4gMDsKPiAgIH0KPiBA QCAtMTg5OCwxMiArMTk2MCwxMiBAQCBzdGF0aWMgaW5saW5lIGludCBzZWN1cml0eV9hdWRpdF9y dWxlX2tub3duKHN0cnVjdCBhdWRpdF9rcnVsZSAqa3J1bGUpCj4gICB9Cj4gICAKPiAgIHN0YXRp YyBpbmxpbmUgaW50IHNlY3VyaXR5X2F1ZGl0X3J1bGVfbWF0Y2godTMyIHNlY2lkLCB1MzIgZmll bGQsIHUzMiBvcCwKPiAtCQkJCQkgICAgdm9pZCAqbHNtcnVsZSkKPiArCQkJCQkgICAgc3RydWN0 IGF1ZGl0X2xzbV9ydWxlcyAqbHNtcnVsZXMpCj4gICB7Cj4gICAJcmV0dXJuIDA7Cj4gICB9Cj4g ICAKPiAtc3RhdGljIGlubGluZSB2b2lkIHNlY3VyaXR5X2F1ZGl0X3J1bGVfZnJlZSh2b2lkICps c21ydWxlKQo+ICtzdGF0aWMgaW5saW5lIHZvaWQgc2VjdXJpdHlfYXVkaXRfcnVsZV9mcmVlKHN0 cnVjdCBhdWRpdF9sc21fcnVsZXMgKmxzbXJ1bGVzKQo+ICAgeyB9Cj4gICAKPiAgICNlbmRpZiAv KiBDT05GSUdfU0VDVVJJVFkgKi8KPiBkaWZmIC0tZ2l0IGEva2VybmVsL2F1ZGl0ZmlsdGVyLmMg Yi9rZXJuZWwvYXVkaXRmaWx0ZXIuYwo+IGluZGV4IDQyZDk5ODk2ZTdhNi4uZGU3NWJkNmFkODY2 IDEwMDY0NAo+IC0tLSBhL2tlcm5lbC9hdWRpdGZpbHRlci5jCj4gKysrIGIva2VybmVsL2F1ZGl0 ZmlsdGVyLmMKPiBAQCAtNzYsNyArNzYsNyBAQCBzdGF0aWMgdm9pZCBhdWRpdF9mcmVlX2xzbV9m aWVsZChzdHJ1Y3QgYXVkaXRfZmllbGQgKmYpCj4gICAJY2FzZSBBVURJVF9PQkpfTEVWX0xPVzoK PiAgIAljYXNlIEFVRElUX09CSl9MRVZfSElHSDoKPiAgIAkJa2ZyZWUoZi0+bHNtX3N0cik7Cj4g LQkJc2VjdXJpdHlfYXVkaXRfcnVsZV9mcmVlKGYtPmxzbV9ydWxlKTsKPiArCQlzZWN1cml0eV9h dWRpdF9ydWxlX2ZyZWUoJmYtPmxzbV9ydWxlcyk7Cj4gICAJfQo+ICAgfQo+ICAgCj4gQEAgLTUy OSw3ICs1MjksNyBAQCBzdGF0aWMgc3RydWN0IGF1ZGl0X2VudHJ5ICphdWRpdF9kYXRhX3RvX2Vu dHJ5KHN0cnVjdCBhdWRpdF9ydWxlX2RhdGEgKmRhdGEsCj4gICAJCQllbnRyeS0+cnVsZS5idWZs ZW4gKz0gZl92YWw7Cj4gICAJCQlmLT5sc21fc3RyID0gc3RyOwo+ICAgCQkJZXJyID0gc2VjdXJp dHlfYXVkaXRfcnVsZV9pbml0KGYtPnR5cGUsIGYtPm9wLCBzdHIsCj4gLQkJCQkJCSAgICAgICAo dm9pZCAqKikmZi0+bHNtX3J1bGUpOwo+ICsJCQkJCQkgICAgICAgJmYtPmxzbV9ydWxlcyk7Cj4g ICAJCQkvKiBLZWVwIGN1cnJlbnRseSBpbnZhbGlkIGZpZWxkcyBhcm91bmQgaW4gY2FzZSB0aGV5 Cj4gICAJCQkgKiBiZWNvbWUgdmFsaWQgYWZ0ZXIgYSBwb2xpY3kgcmVsb2FkLiAqLwo+ICAgCQkJ aWYgKGVyciA9PSAtRUlOVkFMKSB7Cj4gQEAgLTc4Miw3ICs3ODIsNyBAQCBzdGF0aWMgaW50IGF1 ZGl0X2NvbXBhcmVfcnVsZShzdHJ1Y3QgYXVkaXRfa3J1bGUgKmEsIHN0cnVjdCBhdWRpdF9rcnVs ZSAqYikKPiAgIAlyZXR1cm4gMDsKPiAgIH0KPiAgIAo+IC0vKiBEdXBsaWNhdGUgTFNNIGZpZWxk IGluZm9ybWF0aW9uLiAgVGhlIGxzbV9ydWxlIGlzIG9wYXF1ZSwgc28gbXVzdCBiZQo+ICsvKiBE dXBsaWNhdGUgTFNNIGZpZWxkIGluZm9ybWF0aW9uLiAgVGhlIGxzbV9ydWxlcyBpcyBvcGFxdWUs IHNvIG11c3QgYmUKPiAgICAqIHJlLWluaXRpYWxpemVkLiAqLwo+ICAgc3RhdGljIGlubGluZSBp bnQgYXVkaXRfZHVwZV9sc21fZmllbGQoc3RydWN0IGF1ZGl0X2ZpZWxkICpkZiwKPiAgIAkJCQkJ ICAgc3RydWN0IGF1ZGl0X2ZpZWxkICpzZikKPiBAQCAtNzk2LDkgKzc5Niw5IEBAIHN0YXRpYyBp bmxpbmUgaW50IGF1ZGl0X2R1cGVfbHNtX2ZpZWxkKHN0cnVjdCBhdWRpdF9maWVsZCAqZGYsCj4g ICAJCXJldHVybiAtRU5PTUVNOwo+ICAgCWRmLT5sc21fc3RyID0gbHNtX3N0cjsKPiAgIAo+IC0J Lyogb3VyIG93biAocmVmcmVzaGVkKSBjb3B5IG9mIGxzbV9ydWxlICovCj4gKwkvKiBvdXIgb3du IChyZWZyZXNoZWQpIGNvcHkgb2YgbHNtX3J1bGVzICovCj4gICAJcmV0ID0gc2VjdXJpdHlfYXVk aXRfcnVsZV9pbml0KGRmLT50eXBlLCBkZi0+b3AsIGRmLT5sc21fc3RyLAo+IC0JCQkJICAgICAg ICh2b2lkICoqKSZkZi0+bHNtX3J1bGUpOwo+ICsJCQkJICAgICAgICZkZi0+bHNtX3J1bGVzKTsK PiAgIAkvKiBLZWVwIGN1cnJlbnRseSBpbnZhbGlkIGZpZWxkcyBhcm91bmQgaW4gY2FzZSB0aGV5 Cj4gICAJICogYmVjb21lIHZhbGlkIGFmdGVyIGEgcG9saWN5IHJlbG9hZC4gKi8KPiAgIAlpZiAo cmV0ID09IC1FSU5WQUwpIHsKPiBAQCAtODUwLDcgKzg1MCw3IEBAIHN0cnVjdCBhdWRpdF9lbnRy eSAqYXVkaXRfZHVwZV9ydWxlKHN0cnVjdCBhdWRpdF9rcnVsZSAqb2xkKQo+ICAgCW5ldy0+dHJl ZSA9IG9sZC0+dHJlZTsKPiAgIAltZW1jcHkobmV3LT5maWVsZHMsIG9sZC0+ZmllbGRzLCBzaXpl b2Yoc3RydWN0IGF1ZGl0X2ZpZWxkKSAqIGZjb3VudCk7Cj4gICAKPiAtCS8qIGRlZXAgY29weSB0 aGlzIGluZm9ybWF0aW9uLCB1cGRhdGluZyB0aGUgbHNtX3J1bGUgZmllbGRzLCBiZWNhdXNlCj4g KwkvKiBkZWVwIGNvcHkgdGhpcyBpbmZvcm1hdGlvbiwgdXBkYXRpbmcgdGhlIGxzbV9ydWxlcyBm aWVsZHMsIGJlY2F1c2UKPiAgIAkgKiB0aGUgb3JpZ2luYWxzIHdpbGwgYWxsIGJlIGZyZWVkIHdo ZW4gdGhlIG9sZCBydWxlIGlzIGZyZWVkLiAqLwo+ICAgCWZvciAoaSA9IDA7IGkgPCBmY291bnQ7 IGkrKykgewo+ICAgCQlzd2l0Y2ggKG5ldy0+ZmllbGRzW2ldLnR5cGUpIHsKPiBAQCAtMTM2Nywx MCArMTM2NywxMSBAQCBpbnQgYXVkaXRfZmlsdGVyKGludCBtc2d0eXBlLCB1bnNpZ25lZCBpbnQg bGlzdHR5cGUpCj4gICAJCQljYXNlIEFVRElUX1NVQkpfVFlQRToKPiAgIAkJCWNhc2UgQVVESVRf U1VCSl9TRU46Cj4gICAJCQljYXNlIEFVRElUX1NVQkpfQ0xSOgo+IC0JCQkJaWYgKGYtPmxzbV9y dWxlKSB7Cj4gKwkJCQlpZiAoZi0+bHNtX3N0cikgewo+ICAgCQkJCQlzZWN1cml0eV9jdXJyZW50 X2dldHNlY2lkX3N1YmooJnNpZCk7Cj4gICAJCQkJCXJlc3VsdCA9IHNlY3VyaXR5X2F1ZGl0X3J1 bGVfbWF0Y2goc2lkLAo+IC0JCQkJCQkgICBmLT50eXBlLCBmLT5vcCwgZi0+bHNtX3J1bGUpOwo+ ICsJCQkJCQkgICBmLT50eXBlLCBmLT5vcCwKPiArCQkJCQkJICAgJmYtPmxzbV9ydWxlcyk7Cj4g ICAJCQkJfQo+ICAgCQkJCWJyZWFrOwo+ICAgCQkJY2FzZSBBVURJVF9FWEU6Cj4gQEAgLTEzOTcs NyArMTM5OCw3IEBAIGludCBhdWRpdF9maWx0ZXIoaW50IG1zZ3R5cGUsIHVuc2lnbmVkIGludCBs aXN0dHlwZSkKPiAgIAlyZXR1cm4gcmV0Owo+ICAgfQo+ICAgCj4gLXN0YXRpYyBpbnQgdXBkYXRl X2xzbV9ydWxlKHN0cnVjdCBhdWRpdF9rcnVsZSAqcikKPiArc3RhdGljIGludCB1cGRhdGVfbHNt X3J1bGVzKHN0cnVjdCBhdWRpdF9rcnVsZSAqcikKPiAgIHsKPiAgIAlzdHJ1Y3QgYXVkaXRfZW50 cnkgKmVudHJ5ID0gY29udGFpbmVyX29mKHIsIHN0cnVjdCBhdWRpdF9lbnRyeSwgcnVsZSk7Cj4g ICAJc3RydWN0IGF1ZGl0X2VudHJ5ICpuZW50cnk7Cj4gQEAgLTE0MjksNyArMTQzMCw3IEBAIHN0 YXRpYyBpbnQgdXBkYXRlX2xzbV9ydWxlKHN0cnVjdCBhdWRpdF9rcnVsZSAqcikKPiAgIAlyZXR1 cm4gZXJyOwo+ICAgfQo+ICAgCj4gLS8qIFRoaXMgZnVuY3Rpb24gd2lsbCByZS1pbml0aWFsaXpl IHRoZSBsc21fcnVsZSBmaWVsZCBvZiBhbGwgYXBwbGljYWJsZSBydWxlcy4KPiArLyogVGhpcyBm dW5jdGlvbiB3aWxsIHJlLWluaXRpYWxpemUgdGhlIGxzbV9ydWxlcyBmaWVsZCBvZiBhbGwgYXBw bGljYWJsZSBydWxlcy4KPiAgICAqIEl0IHdpbGwgdHJhdmVyc2UgdGhlIGZpbHRlciBsaXN0cyBz ZXJhcmNoaW5nIGZvciBydWxlcyB0aGF0IGNvbnRhaW4gTFNNCj4gICAgKiBzcGVjaWZpYyBmaWx0 ZXIgZmllbGRzLiAgV2hlbiBzdWNoIGEgcnVsZSBpcyBmb3VuZCwgaXQgaXMgY29waWVkLCB0aGUK PiAgICAqIExTTSBmaWVsZCBpcyByZS1pbml0aWFsaXplZCwgYW5kIHRoZSBvbGQgcnVsZSBpcyBy ZXBsYWNlZCB3aXRoIHRoZQo+IEBAIC0xNDQ0LDcgKzE0NDUsNyBAQCBpbnQgYXVkaXRfdXBkYXRl X2xzbV9ydWxlcyh2b2lkKQo+ICAgCj4gICAJZm9yIChpID0gMDsgaSA8IEFVRElUX05SX0ZJTFRF UlM7IGkrKykgewo+ICAgCQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUociwgbiwgJmF1ZGl0X3J1 bGVzX2xpc3RbaV0sIGxpc3QpIHsKPiAtCQkJaW50IHJlcyA9IHVwZGF0ZV9sc21fcnVsZShyKTsK PiArCQkJaW50IHJlcyA9IHVwZGF0ZV9sc21fcnVsZXMocik7Cj4gICAJCQlpZiAoIWVycikKPiAg IAkJCQllcnIgPSByZXM7Cj4gICAJCX0KPiBkaWZmIC0tZ2l0IGEva2VybmVsL2F1ZGl0c2MuYyBi L2tlcm5lbC9hdWRpdHNjLmMKPiBpbmRleCBmY2U1ZDQzYTkzM2YuLmYxYzI2YTMyMmY5ZCAxMDA2 NDQKPiAtLS0gYS9rZXJuZWwvYXVkaXRzYy5jCj4gKysrIGIva2VybmVsL2F1ZGl0c2MuYwo+IEBA IC02NjQsNyArNjY0LDcgQEAgc3RhdGljIGludCBhdWRpdF9maWx0ZXJfcnVsZXMoc3RydWN0IHRh c2tfc3RydWN0ICp0c2ssCj4gICAJCQkgICBtYXRjaCBmb3Igbm93IHRvIGF2b2lkIGxvc2luZyBp bmZvcm1hdGlvbiB0aGF0Cj4gICAJCQkgICBtYXkgYmUgd2FudGVkLiAgIEFuIGVycm9yIG1lc3Nh Z2Ugd2lsbCBhbHNvIGJlCj4gICAJCQkgICBsb2dnZWQgdXBvbiBlcnJvciAqLwo+IC0JCQlpZiAo Zi0+bHNtX3J1bGUpIHsKPiArCQkJaWYgKGYtPmxzbV9zdHIpIHsKPiAgIAkJCQlpZiAobmVlZF9z aWQpIHsKPiAgIAkJCQkJLyogQHRzayBzaG91bGQgYWx3YXlzIGJlIGVxdWFsIHRvCj4gICAJCQkJ CSAqIEBjdXJyZW50IHdpdGggdGhlIGV4Y2VwdGlvbiBvZgo+IEBAIC02NzksOCArNjc5LDcgQEAg c3RhdGljIGludCBhdWRpdF9maWx0ZXJfcnVsZXMoc3RydWN0IHRhc2tfc3RydWN0ICp0c2ssCj4g ICAJCQkJCW5lZWRfc2lkID0gMDsKPiAgIAkJCQl9Cj4gICAJCQkJcmVzdWx0ID0gc2VjdXJpdHlf YXVkaXRfcnVsZV9tYXRjaChzaWQsIGYtPnR5cGUsCj4gLQkJCQkJCQkJICAgZi0+b3AsCj4gLQkJ CQkJCQkJICAgZi0+bHNtX3J1bGUpOwo+ICsJCQkJCQkJZi0+b3AsICZmLT5sc21fcnVsZXMpOwo+ ICAgCQkJfQo+ICAgCQkJYnJlYWs7Cj4gICAJCWNhc2UgQVVESVRfT0JKX1VTRVI6Cj4gQEAgLTY5 MCwyMSArNjg5LDE5IEBAIHN0YXRpYyBpbnQgYXVkaXRfZmlsdGVyX3J1bGVzKHN0cnVjdCB0YXNr X3N0cnVjdCAqdHNrLAo+ICAgCQljYXNlIEFVRElUX09CSl9MRVZfSElHSDoKPiAgIAkJCS8qIFRo ZSBhYm92ZSBub3RlIGZvciBBVURJVF9TVUJKX1VTRVIuLi5BVURJVF9TVUJKX0NMUgo+ICAgCQkJ ICAgYWxzbyBhcHBsaWVzIGhlcmUgKi8KPiAtCQkJaWYgKGYtPmxzbV9ydWxlKSB7Cj4gKwkJCWlm IChmLT5sc21fc3RyKSB7Cj4gICAJCQkJLyogRmluZCBmaWxlcyB0aGF0IG1hdGNoICovCj4gICAJ CQkJaWYgKG5hbWUpIHsKPiAgIAkJCQkJcmVzdWx0ID0gc2VjdXJpdHlfYXVkaXRfcnVsZV9tYXRj aCgKPiAgIAkJCQkJCQkJbmFtZS0+b3NpZCwKPiAgIAkJCQkJCQkJZi0+dHlwZSwKPiAgIAkJCQkJ CQkJZi0+b3AsCj4gLQkJCQkJCQkJZi0+bHNtX3J1bGUpOwo+ICsJCQkJCQkJCSZmLT5sc21fcnVs ZXMpOwo+ICAgCQkJCX0gZWxzZSBpZiAoY3R4KSB7Cj4gICAJCQkJCWxpc3RfZm9yX2VhY2hfZW50 cnkobiwgJmN0eC0+bmFtZXNfbGlzdCwgbGlzdCkgewo+ICAgCQkJCQkJaWYgKHNlY3VyaXR5X2F1 ZGl0X3J1bGVfbWF0Y2goCj4gLQkJCQkJCQkJbi0+b3NpZCwKPiAtCQkJCQkJCQlmLT50eXBlLAo+ IC0JCQkJCQkJCWYtPm9wLAo+IC0JCQkJCQkJCWYtPmxzbV9ydWxlKSkgewo+ICsJCQkJCQkJbi0+ b3NpZCwgZi0+dHlwZSwgZi0+b3AsCj4gKwkJCQkJCQkmZi0+bHNtX3J1bGVzKSkgewo+ICAgCQkJ CQkJCSsrcmVzdWx0Owo+ICAgCQkJCQkJCWJyZWFrOwo+ICAgCQkJCQkJfQo+IEBAIC03MTUsNyAr NzEyLDcgQEAgc3RhdGljIGludCBhdWRpdF9maWx0ZXJfcnVsZXMoc3RydWN0IHRhc2tfc3RydWN0 ICp0c2ssCj4gICAJCQkJCWJyZWFrOwo+ICAgCQkJCWlmIChzZWN1cml0eV9hdWRpdF9ydWxlX21h dGNoKGN0eC0+aXBjLm9zaWQsCj4gICAJCQkJCQkJICAgICAgZi0+dHlwZSwgZi0+b3AsCj4gLQkJ CQkJCQkgICAgICBmLT5sc21fcnVsZSkpCj4gKwkJCQkJCQkgICAgICAmZi0+bHNtX3J1bGVzKSkK PiAgIAkJCQkJKytyZXN1bHQ7Cj4gICAJCQl9Cj4gICAJCQlicmVhazsKPiBkaWZmIC0tZ2l0IGEv c2VjdXJpdHkvYXBwYXJtb3IvbHNtLmMgYi9zZWN1cml0eS9hcHBhcm1vci9sc20uYwo+IGluZGV4 IGJlODk3NmM0MDdmNC4uMWU1M2ZlYTYxMzM1IDEwMDY0NAo+IC0tLSBhL3NlY3VyaXR5L2FwcGFy bW9yL2xzbS5jCj4gKysrIGIvc2VjdXJpdHkvYXBwYXJtb3IvbHNtLmMKPiBAQCAtMTE2OCw2ICsx MTY4LDExIEBAIHN0cnVjdCBsc21fYmxvYl9zaXplcyBhcHBhcm1vcl9ibG9iX3NpemVzIF9fbHNt X3JvX2FmdGVyX2luaXQgPSB7Cj4gICAJLmxic19zb2NrID0gc2l6ZW9mKHN0cnVjdCBhYV9za19j dHgpLAo+ICAgfTsKPiAgIAo+ICtzdGF0aWMgc3RydWN0IGxzbV9pZCBhcHBhcm1vcl9sc21pZCBf X2xzbV9yb19hZnRlcl9pbml0ID0gewo+ICsJLmxzbSAgPSAiYXBwYXJtb3IiLAo+ICsJLnNsb3Qg PSBMU01CTE9CX05FRURFRAo+ICt9Owo+ICsKPiAgIHN0YXRpYyBzdHJ1Y3Qgc2VjdXJpdHlfaG9v a19saXN0IGFwcGFybW9yX2hvb2tzW10gX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKPiAgIAlMU01f SE9PS19JTklUKHB0cmFjZV9hY2Nlc3NfY2hlY2ssIGFwcGFybW9yX3B0cmFjZV9hY2Nlc3NfY2hl Y2spLAo+ICAgCUxTTV9IT09LX0lOSVQocHRyYWNlX3RyYWNlbWUsIGFwcGFybW9yX3B0cmFjZV90 cmFjZW1lKSwKPiBAQCAtMTg1Myw3ICsxODU4LDcgQEAgc3RhdGljIGludCBfX2luaXQgYXBwYXJt b3JfaW5pdCh2b2lkKQo+ICAgCQlnb3RvIGJ1ZmZlcnNfb3V0Owo+ICAgCX0KPiAgIAlzZWN1cml0 eV9hZGRfaG9va3MoYXBwYXJtb3JfaG9va3MsIEFSUkFZX1NJWkUoYXBwYXJtb3JfaG9va3MpLAo+ IC0JCQkJImFwcGFybW9yIik7Cj4gKwkJCQkmYXBwYXJtb3JfbHNtaWQpOwo+ICAgCj4gICAJLyog UmVwb3J0IHRoYXQgQXBwQXJtb3Igc3VjY2Vzc2Z1bGx5IGluaXRpYWxpemVkICovCj4gICAJYXBw YXJtb3JfaW5pdGlhbGl6ZWQgPSAxOwo+IGRpZmYgLS1naXQgYS9zZWN1cml0eS9icGYvaG9va3Mu YyBiL3NlY3VyaXR5L2JwZi9ob29rcy5jCj4gaW5kZXggZTU5NzFmYTc0ZmQ3Li43YTU4ZmU5YWI4 YzQgMTAwNjQ0Cj4gLS0tIGEvc2VjdXJpdHkvYnBmL2hvb2tzLmMKPiArKysgYi9zZWN1cml0eS9i cGYvaG9va3MuYwo+IEBAIC0xNSw5ICsxNSwxOSBAQCBzdGF0aWMgc3RydWN0IHNlY3VyaXR5X2hv b2tfbGlzdCBicGZfbHNtX2hvb2tzW10gX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKPiAgIAlMU01f SE9PS19JTklUKHRhc2tfZnJlZSwgYnBmX3Rhc2tfc3RvcmFnZV9mcmVlKSwKPiAgIH07Cj4gICAK PiArLyoKPiArICogc2xvdCBoYXMgdG8gYmUgTFNNQkxPQl9ORUVERUQgYmVjYXVzZSBzb21lIG9m IHRoZSBob29rcwo+ICsgKiBzdXBwbGllZCBieSB0aGlzIG1vZHVsZSByZXF1aXJlIGEgc2xvdC4K PiArICovCj4gK3N0cnVjdCBsc21faWQgYnBmX2xzbWlkIF9fbHNtX3JvX2FmdGVyX2luaXQgPSB7 Cj4gKwkubHNtID0gImJwZiIsCj4gKwkuc2xvdCA9IExTTUJMT0JfTkVFREVECj4gK307Cj4gKwo+ ICAgc3RhdGljIGludCBfX2luaXQgYnBmX2xzbV9pbml0KHZvaWQpCj4gICB7Cj4gLQlzZWN1cml0 eV9hZGRfaG9va3MoYnBmX2xzbV9ob29rcywgQVJSQVlfU0laRShicGZfbHNtX2hvb2tzKSwgImJw ZiIpOwo+ICsJc2VjdXJpdHlfYWRkX2hvb2tzKGJwZl9sc21faG9va3MsIEFSUkFZX1NJWkUoYnBm X2xzbV9ob29rcyksCj4gKwkJCSAgICZicGZfbHNtaWQpOwo+ICAgCXByX2luZm8oIkxTTSBzdXBw b3J0IGZvciBlQlBGIGFjdGl2ZVxuIik7Cj4gICAJcmV0dXJuIDA7Cj4gICB9Cj4gZGlmZiAtLWdp dCBhL3NlY3VyaXR5L2NvbW1vbmNhcC5jIGIvc2VjdXJpdHkvY29tbW9uY2FwLmMKPiBpbmRleCA1 ZmM4OTg2YzNjNzcuLmM5NGVjNDZlMDdhYyAxMDA2NDQKPiAtLS0gYS9zZWN1cml0eS9jb21tb25j YXAuYwo+ICsrKyBiL3NlY3VyaXR5L2NvbW1vbmNhcC5jCj4gQEAgLTE0NDYsNiArMTQ0NiwxMSBA QCBpbnQgY2FwX21tYXBfZmlsZShzdHJ1Y3QgZmlsZSAqZmlsZSwgdW5zaWduZWQgbG9uZyByZXFw cm90LAo+ICAgCj4gICAjaWZkZWYgQ09ORklHX1NFQ1VSSVRZCj4gICAKPiArc3RhdGljIHN0cnVj dCBsc21faWQgY2FwYWJpbGl0eV9sc21pZCBfX2xzbV9yb19hZnRlcl9pbml0ID0gewo+ICsJLmxz bSAgPSAiY2FwYWJpbGl0eSIsCj4gKwkuc2xvdCA9IExTTUJMT0JfTk9UX05FRURFRAo+ICt9Owo+ ICsKPiAgIHN0YXRpYyBzdHJ1Y3Qgc2VjdXJpdHlfaG9va19saXN0IGNhcGFiaWxpdHlfaG9va3Nb XSBfX2xzbV9yb19hZnRlcl9pbml0ID0gewo+ICAgCUxTTV9IT09LX0lOSVQoY2FwYWJsZSwgY2Fw X2NhcGFibGUpLAo+ICAgCUxTTV9IT09LX0lOSVQoc2V0dGltZSwgY2FwX3NldHRpbWUpLAo+IEBA IC0xNDcwLDcgKzE0NzUsNyBAQCBzdGF0aWMgc3RydWN0IHNlY3VyaXR5X2hvb2tfbGlzdCBjYXBh YmlsaXR5X2hvb2tzW10gX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKPiAgIHN0YXRpYyBpbnQgX19p bml0IGNhcGFiaWxpdHlfaW5pdCh2b2lkKQo+ICAgewo+ICAgCXNlY3VyaXR5X2FkZF9ob29rcyhj YXBhYmlsaXR5X2hvb2tzLCBBUlJBWV9TSVpFKGNhcGFiaWxpdHlfaG9va3MpLAo+IC0JCQkJImNh cGFiaWxpdHkiKTsKPiArCQkJICAgJmNhcGFiaWxpdHlfbHNtaWQpOwo+ICAgCXJldHVybiAwOwo+ ICAgfQo+ICAgCj4gZGlmZiAtLWdpdCBhL3NlY3VyaXR5L2xhbmRsb2NrL2NyZWQuYyBiL3NlY3Vy aXR5L2xhbmRsb2NrL2NyZWQuYwo+IGluZGV4IDY3MjVhZjI0YzY4NC4uNTZiMTIxZDY1NDM2IDEw MDY0NAo+IC0tLSBhL3NlY3VyaXR5L2xhbmRsb2NrL2NyZWQuYwo+ICsrKyBiL3NlY3VyaXR5L2xh bmRsb2NrL2NyZWQuYwo+IEBAIC00Miw1ICs0Miw1IEBAIHN0YXRpYyBzdHJ1Y3Qgc2VjdXJpdHlf aG9va19saXN0IGxhbmRsb2NrX2hvb2tzW10gX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKPiAgIF9f aW5pdCB2b2lkIGxhbmRsb2NrX2FkZF9jcmVkX2hvb2tzKHZvaWQpCj4gICB7Cj4gICAJc2VjdXJp dHlfYWRkX2hvb2tzKGxhbmRsb2NrX2hvb2tzLCBBUlJBWV9TSVpFKGxhbmRsb2NrX2hvb2tzKSwK PiAtCQkJTEFORExPQ0tfTkFNRSk7Cj4gKwkJCSZsYW5kbG9ja19sc21pZCk7Cj4gICB9Cj4gZGlm ZiAtLWdpdCBhL3NlY3VyaXR5L2xhbmRsb2NrL2ZzLmMgYi9zZWN1cml0eS9sYW5kbG9jay9mcy5j Cj4gaW5kZXggOTdiOGU0MjFmNjE3Li4zMTllOTBlOTI5MGMgMTAwNjQ0Cj4gLS0tIGEvc2VjdXJp dHkvbGFuZGxvY2svZnMuYwo+ICsrKyBiL3NlY3VyaXR5L2xhbmRsb2NrL2ZzLmMKPiBAQCAtNjg4 LDUgKzY4OCw1IEBAIHN0YXRpYyBzdHJ1Y3Qgc2VjdXJpdHlfaG9va19saXN0IGxhbmRsb2NrX2hv b2tzW10gX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKPiAgIF9faW5pdCB2b2lkIGxhbmRsb2NrX2Fk ZF9mc19ob29rcyh2b2lkKQo+ICAgewo+ICAgCXNlY3VyaXR5X2FkZF9ob29rcyhsYW5kbG9ja19o b29rcywgQVJSQVlfU0laRShsYW5kbG9ja19ob29rcyksCj4gLQkJCUxBTkRMT0NLX05BTUUpOwo+ ICsJCQkmbGFuZGxvY2tfbHNtaWQpOwo+ICAgfQo+IGRpZmYgLS1naXQgYS9zZWN1cml0eS9sYW5k bG9jay9wdHJhY2UuYyBiL3NlY3VyaXR5L2xhbmRsb2NrL3B0cmFjZS5jCj4gaW5kZXggZjU1Yjgy NDQ2ZGUyLi41NGNjZjU1YTA3N2EgMTAwNjQ0Cj4gLS0tIGEvc2VjdXJpdHkvbGFuZGxvY2svcHRy YWNlLmMKPiArKysgYi9zZWN1cml0eS9sYW5kbG9jay9wdHJhY2UuYwo+IEBAIC0xMTYsNSArMTE2 LDUgQEAgc3RhdGljIHN0cnVjdCBzZWN1cml0eV9ob29rX2xpc3QgbGFuZGxvY2tfaG9va3NbXSBf X2xzbV9yb19hZnRlcl9pbml0ID0gewo+ICAgX19pbml0IHZvaWQgbGFuZGxvY2tfYWRkX3B0cmFj ZV9ob29rcyh2b2lkKQo+ICAgewo+ICAgCXNlY3VyaXR5X2FkZF9ob29rcyhsYW5kbG9ja19ob29r cywgQVJSQVlfU0laRShsYW5kbG9ja19ob29rcyksCj4gLQkJCUxBTkRMT0NLX05BTUUpOwo+ICsJ CQkmbGFuZGxvY2tfbHNtaWQpOwo+ICAgfQo+IGRpZmYgLS1naXQgYS9zZWN1cml0eS9sYW5kbG9j ay9zZXR1cC5jIGIvc2VjdXJpdHkvbGFuZGxvY2svc2V0dXAuYwo+IGluZGV4IGY4ZThlOTgwNDU0 Yy4uNzU5ZTAwYjk0MzZjIDEwMDY0NAo+IC0tLSBhL3NlY3VyaXR5L2xhbmRsb2NrL3NldHVwLmMK PiArKysgYi9zZWN1cml0eS9sYW5kbG9jay9zZXR1cC5jCj4gQEAgLTIzLDYgKzIzLDExIEBAIHN0 cnVjdCBsc21fYmxvYl9zaXplcyBsYW5kbG9ja19ibG9iX3NpemVzIF9fbHNtX3JvX2FmdGVyX2lu aXQgPSB7Cj4gICAJLmxic19zdXBlcmJsb2NrID0gc2l6ZW9mKHN0cnVjdCBsYW5kbG9ja19zdXBl cmJsb2NrX3NlY3VyaXR5KSwKPiAgIH07Cj4gICAKPiArc3RydWN0IGxzbV9pZCBsYW5kbG9ja19s c21pZCBfX2xzbV9yb19hZnRlcl9pbml0ID0gewo+ICsJLmxzbSA9IExBTkRMT0NLX05BTUUsCj4g Kwkuc2xvdCA9IExTTUJMT0JfTk9UX05FRURFRCwKPiArfTsKPiArCj4gICBzdGF0aWMgaW50IF9f aW5pdCBsYW5kbG9ja19pbml0KHZvaWQpCj4gICB7Cj4gICAJbGFuZGxvY2tfYWRkX2NyZWRfaG9v a3MoKTsKPiBkaWZmIC0tZ2l0IGEvc2VjdXJpdHkvbGFuZGxvY2svc2V0dXAuaCBiL3NlY3VyaXR5 L2xhbmRsb2NrL3NldHVwLmgKPiBpbmRleCAxZGFmZmFiMWFiNGIuLjM4YmNlNWIxNzJkYyAxMDA2 NDQKPiAtLS0gYS9zZWN1cml0eS9sYW5kbG9jay9zZXR1cC5oCj4gKysrIGIvc2VjdXJpdHkvbGFu ZGxvY2svc2V0dXAuaAo+IEBAIC0xNCw1ICsxNCw2IEBACj4gICBleHRlcm4gYm9vbCBsYW5kbG9j a19pbml0aWFsaXplZDsKPiAgIAo+ICAgZXh0ZXJuIHN0cnVjdCBsc21fYmxvYl9zaXplcyBsYW5k bG9ja19ibG9iX3NpemVzOwo+ICtleHRlcm4gc3RydWN0IGxzbV9pZCBsYW5kbG9ja19sc21pZDsK PiAgIAo+ICAgI2VuZGlmIC8qIF9TRUNVUklUWV9MQU5ETE9DS19TRVRVUF9IICovCj4gZGlmZiAt LWdpdCBhL3NlY3VyaXR5L2xvYWRwaW4vbG9hZHBpbi5jIGIvc2VjdXJpdHkvbG9hZHBpbi9sb2Fk cGluLmMKPiBpbmRleCBiMTJmN2Q5ODZiMWUuLmI1NjlmM2JjMTcwYiAxMDA2NDQKPiAtLS0gYS9z ZWN1cml0eS9sb2FkcGluL2xvYWRwaW4uYwo+ICsrKyBiL3NlY3VyaXR5L2xvYWRwaW4vbG9hZHBp bi5jCj4gQEAgLTE5Miw2ICsxOTIsMTEgQEAgc3RhdGljIGludCBsb2FkcGluX2xvYWRfZGF0YShl bnVtIGtlcm5lbF9sb2FkX2RhdGFfaWQgaWQsIGJvb2wgY29udGVudHMpCj4gICAJcmV0dXJuIGxv YWRwaW5fcmVhZF9maWxlKE5VTEwsIChlbnVtIGtlcm5lbF9yZWFkX2ZpbGVfaWQpIGlkLCBjb250 ZW50cyk7Cj4gICB9Cj4gICAKPiArc3RhdGljIHN0cnVjdCBsc21faWQgbG9hZHBpbl9sc21pZCBf X2xzbV9yb19hZnRlcl9pbml0ID0gewo+ICsJLmxzbSAgPSAibG9hZHBpbiIsCj4gKwkuc2xvdCA9 IExTTUJMT0JfTk9UX05FRURFRAo+ICt9Owo+ICsKPiAgIHN0YXRpYyBzdHJ1Y3Qgc2VjdXJpdHlf aG9va19saXN0IGxvYWRwaW5faG9va3NbXSBfX2xzbV9yb19hZnRlcl9pbml0ID0gewo+ICAgCUxT TV9IT09LX0lOSVQoc2JfZnJlZV9zZWN1cml0eSwgbG9hZHBpbl9zYl9mcmVlX3NlY3VyaXR5KSwK PiAgIAlMU01fSE9PS19JTklUKGtlcm5lbF9yZWFkX2ZpbGUsIGxvYWRwaW5fcmVhZF9maWxlKSwK PiBAQCAtMjM5LDcgKzI0NCw4IEBAIHN0YXRpYyBpbnQgX19pbml0IGxvYWRwaW5faW5pdCh2b2lk KQo+ICAgCXByX2luZm8oInJlYWR5IHRvIHBpbiAoY3VycmVudGx5ICVzZW5mb3JjaW5nKVxuIiwK PiAgIAkJZW5mb3JjZSA/ICIiIDogIm5vdCAiKTsKPiAgIAlwYXJzZV9leGNsdWRlKCk7Cj4gLQlz ZWN1cml0eV9hZGRfaG9va3MobG9hZHBpbl9ob29rcywgQVJSQVlfU0laRShsb2FkcGluX2hvb2tz KSwgImxvYWRwaW4iKTsKPiArCXNlY3VyaXR5X2FkZF9ob29rcyhsb2FkcGluX2hvb2tzLCBBUlJB WV9TSVpFKGxvYWRwaW5faG9va3MpLAo+ICsJCQkgICAmbG9hZHBpbl9sc21pZCk7Cj4gICAJcmV0 dXJuIDA7Cj4gICB9Cj4gICAKPiBkaWZmIC0tZ2l0IGEvc2VjdXJpdHkvbG9ja2Rvd24vbG9ja2Rv d24uYyBiL3NlY3VyaXR5L2xvY2tkb3duL2xvY2tkb3duLmMKPiBpbmRleCA4N2NiZGM2NGQyNzIu LjRlMjRlYTNmN2I3ZSAxMDA2NDQKPiAtLS0gYS9zZWN1cml0eS9sb2NrZG93bi9sb2NrZG93bi5j Cj4gKysrIGIvc2VjdXJpdHkvbG9ja2Rvd24vbG9ja2Rvd24uYwo+IEBAIC03NSw2ICs3NSwxMSBA QCBzdGF0aWMgc3RydWN0IHNlY3VyaXR5X2hvb2tfbGlzdCBsb2NrZG93bl9ob29rc1tdIF9fbHNt X3JvX2FmdGVyX2luaXQgPSB7Cj4gICAJTFNNX0hPT0tfSU5JVChsb2NrZWRfZG93biwgbG9ja2Rv d25faXNfbG9ja2VkX2Rvd24pLAo+ICAgfTsKPiAgIAo+ICtzdGF0aWMgc3RydWN0IGxzbV9pZCBs b2NrZG93bl9sc21pZCBfX2xzbV9yb19hZnRlcl9pbml0ID0gewo+ICsJLmxzbSA9ICJsb2NrZG93 biIsCj4gKwkuc2xvdCA9IExTTUJMT0JfTk9UX05FRURFRAo+ICt9Owo+ICsKPiAgIHN0YXRpYyBp bnQgX19pbml0IGxvY2tkb3duX2xzbV9pbml0KHZvaWQpCj4gICB7Cj4gICAjaWYgZGVmaW5lZChD T05GSUdfTE9DS19ET1dOX0tFUk5FTF9GT1JDRV9JTlRFR1JJVFkpCj4gQEAgLTgzLDcgKzg4LDcg QEAgc3RhdGljIGludCBfX2luaXQgbG9ja2Rvd25fbHNtX2luaXQodm9pZCkKPiAgIAlsb2NrX2tl cm5lbF9kb3duKCJLZXJuZWwgY29uZmlndXJhdGlvbiIsIExPQ0tET1dOX0NPTkZJREVOVElBTElU WV9NQVgpOwo+ICAgI2VuZGlmCj4gICAJc2VjdXJpdHlfYWRkX2hvb2tzKGxvY2tkb3duX2hvb2tz LCBBUlJBWV9TSVpFKGxvY2tkb3duX2hvb2tzKSwKPiAtCQkJICAgImxvY2tkb3duIik7Cj4gKwkJ CSAgICZsb2NrZG93bl9sc21pZCk7Cj4gICAJcmV0dXJuIDA7Cj4gICB9Cj4gICAKPiBkaWZmIC0t Z2l0IGEvc2VjdXJpdHkvc2FmZXNldGlkL2xzbS5jIGIvc2VjdXJpdHkvc2FmZXNldGlkL2xzbS5j Cj4gaW5kZXggOTYzZjRhZDljYjY2Li4wYzM2ODk1MGRjMTQgMTAwNjQ0Cj4gLS0tIGEvc2VjdXJp dHkvc2FmZXNldGlkL2xzbS5jCj4gKysrIGIvc2VjdXJpdHkvc2FmZXNldGlkL2xzbS5jCj4gQEAg LTI0MSw2ICsyNDEsMTEgQEAgc3RhdGljIGludCBzYWZlc2V0aWRfdGFza19maXhfc2V0Z2lkKHN0 cnVjdCBjcmVkICpuZXcsCj4gICAJcmV0dXJuIC1FQUNDRVM7Cj4gICB9Cj4gICAKPiArc3RhdGlj IHN0cnVjdCBsc21faWQgc2FmZXNldGlkX2xzbWlkIF9fbHNtX3JvX2FmdGVyX2luaXQgPSB7Cj4g KwkubHNtICA9ICJzYWZlc2V0aWQiLAo+ICsJLnNsb3QgPSBMU01CTE9CX05PVF9ORUVERUQKPiAr fTsKPiArCj4gICBzdGF0aWMgc3RydWN0IHNlY3VyaXR5X2hvb2tfbGlzdCBzYWZlc2V0aWRfc2Vj dXJpdHlfaG9va3NbXSA9IHsKPiAgIAlMU01fSE9PS19JTklUKHRhc2tfZml4X3NldHVpZCwgc2Fm ZXNldGlkX3Rhc2tfZml4X3NldHVpZCksCj4gICAJTFNNX0hPT0tfSU5JVCh0YXNrX2ZpeF9zZXRn aWQsIHNhZmVzZXRpZF90YXNrX2ZpeF9zZXRnaWQpLAo+IEBAIC0yNTAsNyArMjU1LDggQEAgc3Rh dGljIHN0cnVjdCBzZWN1cml0eV9ob29rX2xpc3Qgc2FmZXNldGlkX3NlY3VyaXR5X2hvb2tzW10g PSB7Cj4gICBzdGF0aWMgaW50IF9faW5pdCBzYWZlc2V0aWRfc2VjdXJpdHlfaW5pdCh2b2lkKQo+ ICAgewo+ICAgCXNlY3VyaXR5X2FkZF9ob29rcyhzYWZlc2V0aWRfc2VjdXJpdHlfaG9va3MsCj4g LQkJCSAgIEFSUkFZX1NJWkUoc2FmZXNldGlkX3NlY3VyaXR5X2hvb2tzKSwgInNhZmVzZXRpZCIp Owo+ICsJCQkgICBBUlJBWV9TSVpFKHNhZmVzZXRpZF9zZWN1cml0eV9ob29rcyksCj4gKwkJCSAg ICZzYWZlc2V0aWRfbHNtaWQpOwo+ICAgCj4gICAJLyogUmVwb3J0IHRoYXQgU2FmZVNldElEIHN1 Y2Nlc3NmdWxseSBpbml0aWFsaXplZCAqLwo+ICAgCXNhZmVzZXRpZF9pbml0aWFsaXplZCA9IDE7 Cj4gZGlmZiAtLWdpdCBhL3NlY3VyaXR5L3NlY3VyaXR5LmMgYi9zZWN1cml0eS9zZWN1cml0eS5j Cj4gaW5kZXggZjJkNGIyMDYxM2M4Li4yYmYyMWM3MjZiYTAgMTAwNjQ0Cj4gLS0tIGEvc2VjdXJp dHkvc2VjdXJpdHkuYwo+ICsrKyBiL3NlY3VyaXR5L3NlY3VyaXR5LmMKPiBAQCAtMzQ1LDYgKzM0 NSw3IEBAIHN0YXRpYyB2b2lkIF9faW5pdCBvcmRlcmVkX2xzbV9pbml0KHZvaWQpCj4gICAJaW5p dF9kZWJ1Zygic29jayBibG9iIHNpemUgICAgICAgPSAlZFxuIiwgYmxvYl9zaXplcy5sYnNfc29j ayk7Cj4gICAJaW5pdF9kZWJ1Zygic3VwZXJibG9jayBibG9iIHNpemUgPSAlZFxuIiwgYmxvYl9z aXplcy5sYnNfc3VwZXJibG9jayk7Cj4gICAJaW5pdF9kZWJ1ZygidGFzayBibG9iIHNpemUgICAg ICAgPSAlZFxuIiwgYmxvYl9zaXplcy5sYnNfdGFzayk7Cj4gKwlpbml0X2RlYnVnKCJsc21ibG9i IHNpemUgICAgICAgICA9ICV6dVxuIiwgc2l6ZW9mKHN0cnVjdCBsc21ibG9iKSk7Cj4gICAKPiAg IAkvKgo+ICAgCSAqIENyZWF0ZSBhbnkga21lbV9jYWNoZXMgbmVlZGVkIGZvciBibG9icwo+IEBA IC00NzIsMjEgKzQ3MywzOCBAQCBzdGF0aWMgaW50IGxzbV9hcHBlbmQoY29uc3QgY2hhciAqbmV3 LCBjaGFyICoqcmVzdWx0KQo+ICAgCXJldHVybiAwOwo+ICAgfQo+ICAgCj4gKy8qCj4gKyAqIEN1 cnJlbnQgaW5kZXggdG8gdXNlIHdoaWxlIGluaXRpYWxpemluZyB0aGUgbHNtYmxvYiBzZWNpZCBs aXN0Lgo+ICsgKi8KPiArc3RhdGljIGludCBsc21fc2xvdCBfX2xzbV9yb19hZnRlcl9pbml0Owo+ ICsKPiAgIC8qKgo+ICAgICogc2VjdXJpdHlfYWRkX2hvb2tzIC0gQWRkIGEgbW9kdWxlcyBob29r cyB0byB0aGUgaG9vayBsaXN0cy4KPiAgICAqIEBob29rczogdGhlIGhvb2tzIHRvIGFkZAo+ICAg ICogQGNvdW50OiB0aGUgbnVtYmVyIG9mIGhvb2tzIHRvIGFkZAo+IC0gKiBAbHNtOiB0aGUgbmFt ZSBvZiB0aGUgc2VjdXJpdHkgbW9kdWxlCj4gKyAqIEBsc21pZDogdGhlIGlkZW50aWZpY2F0aW9u IGluZm9ybWF0aW9uIGZvciB0aGUgc2VjdXJpdHkgbW9kdWxlCj4gICAgKgo+ICAgICogRWFjaCBM U00gaGFzIHRvIHJlZ2lzdGVyIGl0cyBob29rcyB3aXRoIHRoZSBpbmZyYXN0cnVjdHVyZS4KPiAr ICogSWYgdGhlIExTTSBpcyB1c2luZyBob29rcyB0aGF0IGV4cG9ydCBzZWNpZHMgYWxsb2NhdGUg YSBzbG90Cj4gKyAqIGZvciBpdCBpbiB0aGUgbHNtYmxvYi4KPiAgICAqLwo+ICAgdm9pZCBfX2lu aXQgc2VjdXJpdHlfYWRkX2hvb2tzKHN0cnVjdCBzZWN1cml0eV9ob29rX2xpc3QgKmhvb2tzLCBp bnQgY291bnQsCj4gLQkJCQljaGFyICpsc20pCj4gKwkJCSAgICAgICBzdHJ1Y3QgbHNtX2lkICps c21pZCkKPiAgIHsKPiAgIAlpbnQgaTsKPiAgIAo+ICsJV0FSTl9PTighbHNtaWQtPnNsb3QgfHwg IWxzbWlkLT5sc20pOwo+ICsKPiArCWlmIChsc21pZC0+c2xvdCA9PSBMU01CTE9CX05FRURFRCkg ewo+ICsJCWlmIChsc21fc2xvdCA+PSBMU01CTE9CX0VOVFJJRVMpCj4gKwkJCXBhbmljKCIlcyBU b28gbWFueSBMU01zIHJlZ2lzdGVyZWQuXG4iLCBfX2Z1bmNfXyk7Cj4gKwkJbHNtaWQtPnNsb3Qg PSBsc21fc2xvdCsrOwo+ICsJCWluaXRfZGVidWcoIiVzIGFzc2lnbmVkIGxzbWJsb2Igc2xvdCAl ZFxuIiwgbHNtaWQtPmxzbSwKPiArCQkJICAgbHNtaWQtPnNsb3QpOwo+ICsJfQo+ICsKPiAgIAlm b3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykgewo+IC0JCWhvb2tzW2ldLmxzbSA9IGxzbTsKPiAr CQlob29rc1tpXS5sc21pZCA9IGxzbWlkOwo+ICAgCQlobGlzdF9hZGRfdGFpbF9yY3UoJmhvb2tz W2ldLmxpc3QsIGhvb2tzW2ldLmhlYWQpOwo+ICAgCX0KPiAgIAo+IEBAIC00OTUsNyArNTEzLDcg QEAgdm9pZCBfX2luaXQgc2VjdXJpdHlfYWRkX2hvb2tzKHN0cnVjdCBzZWN1cml0eV9ob29rX2xp c3QgKmhvb2tzLCBpbnQgY291bnQsCj4gICAJICogYW5kIGZpeCB0aGlzIHVwIGFmdGVyd2FyZHMu Cj4gICAJICovCj4gICAJaWYgKHNsYWJfaXNfYXZhaWxhYmxlKCkpIHsKPiAtCQlpZiAobHNtX2Fw cGVuZChsc20sICZsc21fbmFtZXMpIDwgMCkKPiArCQlpZiAobHNtX2FwcGVuZChsc21pZC0+bHNt LCAmbHNtX25hbWVzKSA8IDApCj4gICAJCQlwYW5pYygiJXMgLSBDYW5ub3QgZ2V0IGVhcmx5IG1l bW9yeS5cbiIsIF9fZnVuY19fKTsKPiAgIAl9Cj4gICB9Cj4gQEAgLTIwNzUsNyArMjA5Myw3IEBA IGludCBzZWN1cml0eV9nZXRwcm9jYXR0cihzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAsIGNvbnN0IGNo YXIgKmxzbSwgY2hhciAqbmFtZSwKPiAgIAlzdHJ1Y3Qgc2VjdXJpdHlfaG9va19saXN0ICpocDsK PiAgIAo+ICAgCWhsaXN0X2Zvcl9lYWNoX2VudHJ5KGhwLCAmc2VjdXJpdHlfaG9va19oZWFkcy5n ZXRwcm9jYXR0ciwgbGlzdCkgewo+IC0JCWlmIChsc20gIT0gTlVMTCAmJiBzdHJjbXAobHNtLCBo cC0+bHNtKSkKPiArCQlpZiAobHNtICE9IE5VTEwgJiYgc3RyY21wKGxzbSwgaHAtPmxzbWlkLT5s c20pKQo+ICAgCQkJY29udGludWU7Cj4gICAJCXJldHVybiBocC0+aG9vay5nZXRwcm9jYXR0cihw LCBuYW1lLCB2YWx1ZSk7Cj4gICAJfQo+IEBAIC0yMDg4LDcgKzIxMDYsNyBAQCBpbnQgc2VjdXJp dHlfc2V0cHJvY2F0dHIoY29uc3QgY2hhciAqbHNtLCBjb25zdCBjaGFyICpuYW1lLCB2b2lkICp2 YWx1ZSwKPiAgIAlzdHJ1Y3Qgc2VjdXJpdHlfaG9va19saXN0ICpocDsKPiAgIAo+ICAgCWhsaXN0 X2Zvcl9lYWNoX2VudHJ5KGhwLCAmc2VjdXJpdHlfaG9va19oZWFkcy5zZXRwcm9jYXR0ciwgbGlz dCkgewo+IC0JCWlmIChsc20gIT0gTlVMTCAmJiBzdHJjbXAobHNtLCBocC0+bHNtKSkKPiArCQlp ZiAobHNtICE9IE5VTEwgJiYgc3RyY21wKGxzbSwgaHAtPmxzbWlkLT5sc20pKQo+ICAgCQkJY29u dGludWU7Cj4gICAJCXJldHVybiBocC0+aG9vay5zZXRwcm9jYXR0cihuYW1lLCB2YWx1ZSwgc2l6 ZSk7Cj4gICAJfQo+IEBAIC0yNTc5LDkgKzI1OTcsMjcgQEAgaW50IHNlY3VyaXR5X2tleV9nZXRz ZWN1cml0eShzdHJ1Y3Qga2V5ICprZXksIGNoYXIgKipfYnVmZmVyKQo+ICAgCj4gICAjaWZkZWYg Q09ORklHX0FVRElUCj4gICAKPiAtaW50IHNlY3VyaXR5X2F1ZGl0X3J1bGVfaW5pdCh1MzIgZmll bGQsIHUzMiBvcCwgY2hhciAqcnVsZXN0ciwgdm9pZCAqKmxzbXJ1bGUpCj4gK2ludCBzZWN1cml0 eV9hdWRpdF9ydWxlX2luaXQodTMyIGZpZWxkLCB1MzIgb3AsIGNoYXIgKnJ1bGVzdHIsCj4gKwkJ CSAgICAgc3RydWN0IGF1ZGl0X2xzbV9ydWxlcyAqbHNtcnVsZXMpCj4gICB7Cj4gLQlyZXR1cm4g Y2FsbF9pbnRfaG9vayhhdWRpdF9ydWxlX2luaXQsIDAsIGZpZWxkLCBvcCwgcnVsZXN0ciwgbHNt cnVsZSk7Cj4gKwlzdHJ1Y3Qgc2VjdXJpdHlfaG9va19saXN0ICpocDsKPiArCWJvb2wgb25lX2lz X2dvb2QgPSBmYWxzZTsKPiArCWludCByYyA9IDA7Cj4gKwlpbnQgdHJjOwo+ICsKPiArCWhsaXN0 X2Zvcl9lYWNoX2VudHJ5KGhwLCAmc2VjdXJpdHlfaG9va19oZWFkcy5hdWRpdF9ydWxlX2luaXQs IGxpc3QpIHsKPiArCQlpZiAoV0FSTl9PTihocC0+bHNtaWQtPnNsb3QgPCAwIHx8IGhwLT5sc21p ZC0+c2xvdCA+PSBsc21fc2xvdCkpCj4gKwkJCWNvbnRpbnVlOwo+ICsJCXRyYyA9IGhwLT5ob29r LmF1ZGl0X3J1bGVfaW5pdChmaWVsZCwgb3AsIHJ1bGVzdHIsCj4gKwkJCQkJJmxzbXJ1bGVzLT5y dWxlW2hwLT5sc21pZC0+c2xvdF0pOwo+ICsJCWlmICh0cmMgPT0gMCkKPiArCQkJb25lX2lzX2dv b2QgPSB0cnVlOwo+ICsJCWVsc2UKPiArCQkJcmMgPSB0cmM7Cj4gKwl9Cj4gKwlpZiAob25lX2lz X2dvb2QpCj4gKwkJcmV0dXJuIDA7Cj4gKwlyZXR1cm4gcmM7Cj4gICB9Cj4gICAKPiAgIGludCBz ZWN1cml0eV9hdWRpdF9ydWxlX2tub3duKHN0cnVjdCBhdWRpdF9rcnVsZSAqa3J1bGUpCj4gQEAg LTI1ODksMTQgKzI2MjUsMzYgQEAgaW50IHNlY3VyaXR5X2F1ZGl0X3J1bGVfa25vd24oc3RydWN0 IGF1ZGl0X2tydWxlICprcnVsZSkKPiAgIAlyZXR1cm4gY2FsbF9pbnRfaG9vayhhdWRpdF9ydWxl X2tub3duLCAwLCBrcnVsZSk7Cj4gICB9Cj4gICAKPiAtdm9pZCBzZWN1cml0eV9hdWRpdF9ydWxl X2ZyZWUodm9pZCAqbHNtcnVsZSkKPiArdm9pZCBzZWN1cml0eV9hdWRpdF9ydWxlX2ZyZWUoc3Ry dWN0IGF1ZGl0X2xzbV9ydWxlcyAqbHNtcnVsZXMpCj4gICB7Cj4gLQljYWxsX3ZvaWRfaG9vayhh dWRpdF9ydWxlX2ZyZWUsIGxzbXJ1bGUpOwo+ICsJc3RydWN0IHNlY3VyaXR5X2hvb2tfbGlzdCAq aHA7Cj4gKwo+ICsJaGxpc3RfZm9yX2VhY2hfZW50cnkoaHAsICZzZWN1cml0eV9ob29rX2hlYWRz LmF1ZGl0X3J1bGVfZnJlZSwgbGlzdCkgewo+ICsJCWlmIChXQVJOX09OKGhwLT5sc21pZC0+c2xv dCA8IDAgfHwgaHAtPmxzbWlkLT5zbG90ID49IGxzbV9zbG90KSkKPiArCQkJY29udGludWU7Cj4g KwkJaWYgKGxzbXJ1bGVzLT5ydWxlW2hwLT5sc21pZC0+c2xvdF0gPT0gTlVMTCkKPiArCQkJY29u dGludWU7Cj4gKwkJaHAtPmhvb2suYXVkaXRfcnVsZV9mcmVlKGxzbXJ1bGVzLT5ydWxlW2hwLT5s c21pZC0+c2xvdF0pOwo+ICsJfQo+ICAgfQo+ICAgCj4gLWludCBzZWN1cml0eV9hdWRpdF9ydWxl X21hdGNoKHUzMiBzZWNpZCwgdTMyIGZpZWxkLCB1MzIgb3AsIHZvaWQgKmxzbXJ1bGUpCj4gK2lu dCBzZWN1cml0eV9hdWRpdF9ydWxlX21hdGNoKHUzMiBzZWNpZCwgdTMyIGZpZWxkLCB1MzIgb3As Cj4gKwkJCSAgICAgIHN0cnVjdCBhdWRpdF9sc21fcnVsZXMgKmxzbXJ1bGVzKQo+ICAgewo+IC0J cmV0dXJuIGNhbGxfaW50X2hvb2soYXVkaXRfcnVsZV9tYXRjaCwgMCwgc2VjaWQsIGZpZWxkLCBv cCwgbHNtcnVsZSk7Cj4gKwlzdHJ1Y3Qgc2VjdXJpdHlfaG9va19saXN0ICpocDsKPiArCWludCBy YzsKPiArCj4gKwlobGlzdF9mb3JfZWFjaF9lbnRyeShocCwgJnNlY3VyaXR5X2hvb2tfaGVhZHMu YXVkaXRfcnVsZV9tYXRjaCwgbGlzdCkgewo+ICsJCWlmIChXQVJOX09OKGhwLT5sc21pZC0+c2xv dCA8IDAgfHwgaHAtPmxzbWlkLT5zbG90ID49IGxzbV9zbG90KSkKPiArCQkJY29udGludWU7Cj4g KwkJaWYgKGxzbXJ1bGVzLT5ydWxlW2hwLT5sc21pZC0+c2xvdF0gPT0gTlVMTCkKPiArCQkJY29u dGludWU7Cj4gKwkJcmMgPSBocC0+aG9vay5hdWRpdF9ydWxlX21hdGNoKHNlY2lkLCBmaWVsZCwg b3AsCj4gKwkJCQkJJmxzbXJ1bGVzLT5ydWxlW2hwLT5sc21pZC0+c2xvdF0pOwo+ICsJCWlmIChy YykKPiArCQkJcmV0dXJuIHJjOwo+ICsJfQo+ICsJcmV0dXJuIDA7Cj4gICB9Cj4gICAjZW5kaWYg LyogQ09ORklHX0FVRElUICovCj4gICAKPiBkaWZmIC0tZ2l0IGEvc2VjdXJpdHkvc2VsaW51eC9o b29rcy5jIGIvc2VjdXJpdHkvc2VsaW51eC9ob29rcy5jCj4gaW5kZXggZGZmZGU0MGQzNjdlLi5k NjdiY2QxYWVhZjUgMTAwNjQ0Cj4gLS0tIGEvc2VjdXJpdHkvc2VsaW51eC9ob29rcy5jCj4gKysr IGIvc2VjdXJpdHkvc2VsaW51eC9ob29rcy5jCj4gQEAgLTcwMDksNiArNzAwOSwxMSBAQCBzdGF0 aWMgaW50IHNlbGludXhfdXJpbmdfc3Fwb2xsKHZvaWQpCj4gICB9Cj4gICAjZW5kaWYgLyogQ09O RklHX0lPX1VSSU5HICovCj4gICAKPiArc3RhdGljIHN0cnVjdCBsc21faWQgc2VsaW51eF9sc21p ZCBfX2xzbV9yb19hZnRlcl9pbml0ID0gewo+ICsJLmxzbSAgPSAic2VsaW51eCIsCj4gKwkuc2xv dCA9IExTTUJMT0JfTkVFREVECj4gK307Cj4gKwo+ICAgLyoKPiAgICAqIElNUE9SVEFOVCBOT1RF OiBXaGVuIGFkZGluZyBuZXcgaG9va3MsIHBsZWFzZSBiZSBjYXJlZnVsIHRvIGtlZXAgdGhpcyBv cmRlcjoKPiAgICAqIDEuIGFueSBob29rcyB0aGF0IGRvbid0IGJlbG9uZyB0byAoMi4pIG9yICgz LikgYmVsb3csCj4gQEAgLTczMjQsNyArNzMyOSw4IEBAIHN0YXRpYyBfX2luaXQgaW50IHNlbGlu dXhfaW5pdCh2b2lkKQo+ICAgCj4gICAJaGFzaHRhYl9jYWNoZV9pbml0KCk7Cj4gICAKPiAtCXNl Y3VyaXR5X2FkZF9ob29rcyhzZWxpbnV4X2hvb2tzLCBBUlJBWV9TSVpFKHNlbGludXhfaG9va3Mp LCAic2VsaW51eCIpOwo+ICsJc2VjdXJpdHlfYWRkX2hvb2tzKHNlbGludXhfaG9va3MsIEFSUkFZ X1NJWkUoc2VsaW51eF9ob29rcyksCj4gKwkJCSAgICZzZWxpbnV4X2xzbWlkKTsKPiAgIAo+ICAg CWlmIChhdmNfYWRkX2NhbGxiYWNrKHNlbGludXhfbmV0Y2FjaGVfYXZjX2NhbGxiYWNrLCBBVkNf Q0FMTEJBQ0tfUkVTRVQpKQo+ICAgCQlwYW5pYygiU0VMaW51eDogVW5hYmxlIHRvIHJlZ2lzdGVy IEFWQyBuZXRjYWNoZSBjYWxsYmFja1xuIik7Cj4gZGlmZiAtLWdpdCBhL3NlY3VyaXR5L3NtYWNr L3NtYWNrX2xzbS5jIGIvc2VjdXJpdHkvc21hY2svc21hY2tfbHNtLmMKPiBpbmRleCBkNThiNTAw MDZlNzkuLmZmODMyZDQ3NDc5ZiAxMDA2NDQKPiAtLS0gYS9zZWN1cml0eS9zbWFjay9zbWFja19s c20uYwo+ICsrKyBiL3NlY3VyaXR5L3NtYWNrL3NtYWNrX2xzbS5jCj4gQEAgLTQ3NDQsNiArNDc0 NCwxMSBAQCBzdHJ1Y3QgbHNtX2Jsb2Jfc2l6ZXMgc21hY2tfYmxvYl9zaXplcyBfX2xzbV9yb19h ZnRlcl9pbml0ID0gewo+ICAgCS5sYnNfc3VwZXJibG9jayA9IHNpemVvZihzdHJ1Y3Qgc3VwZXJi bG9ja19zbWFjayksCj4gICB9Owo+ICAgCj4gK3N0YXRpYyBzdHJ1Y3QgbHNtX2lkIHNtYWNrX2xz bWlkIF9fbHNtX3JvX2FmdGVyX2luaXQgPSB7Cj4gKwkubHNtICA9ICJzbWFjayIsCj4gKwkuc2xv dCA9IExTTUJMT0JfTkVFREVECj4gK307Cj4gKwo+ICAgc3RhdGljIHN0cnVjdCBzZWN1cml0eV9o b29rX2xpc3Qgc21hY2tfaG9va3NbXSBfX2xzbV9yb19hZnRlcl9pbml0ID0gewo+ICAgCUxTTV9I T09LX0lOSVQocHRyYWNlX2FjY2Vzc19jaGVjaywgc21hY2tfcHRyYWNlX2FjY2Vzc19jaGVjayks Cj4gICAJTFNNX0hPT0tfSU5JVChwdHJhY2VfdHJhY2VtZSwgc21hY2tfcHRyYWNlX3RyYWNlbWUp LAo+IEBAIC00OTQ3LDcgKzQ5NTIsNyBAQCBzdGF0aWMgX19pbml0IGludCBzbWFja19pbml0KHZv aWQpCj4gICAJLyoKPiAgIAkgKiBSZWdpc3RlciB3aXRoIExTTQo+ICAgCSAqLwo+IC0Jc2VjdXJp dHlfYWRkX2hvb2tzKHNtYWNrX2hvb2tzLCBBUlJBWV9TSVpFKHNtYWNrX2hvb2tzKSwgInNtYWNr Iik7Cj4gKwlzZWN1cml0eV9hZGRfaG9va3Moc21hY2tfaG9va3MsIEFSUkFZX1NJWkUoc21hY2tf aG9va3MpLCAmc21hY2tfbHNtaWQpOwo+ICAgCXNtYWNrX2VuYWJsZWQgPSAxOwo+ICAgCj4gICAJ cHJfaW5mbygiU21hY2s6ICBJbml0aWFsaXppbmcuXG4iKTsKPiBkaWZmIC0tZ2l0IGEvc2VjdXJp dHkvdG9tb3lvL3RvbW95by5jIGIvc2VjdXJpdHkvdG9tb3lvL3RvbW95by5jCj4gaW5kZXggYjZh MzE5MDFmMjg5Li5lOGY2YmI5NzgyYzEgMTAwNjQ0Cj4gLS0tIGEvc2VjdXJpdHkvdG9tb3lvL3Rv bW95by5jCj4gKysrIGIvc2VjdXJpdHkvdG9tb3lvL3RvbW95by5jCj4gQEAgLTUyMSw2ICs1MjEs MTEgQEAgc3RhdGljIHZvaWQgdG9tb3lvX3Rhc2tfZnJlZShzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRh c2spCj4gICAJfQo+ICAgfQo+ICAgCj4gK3N0YXRpYyBzdHJ1Y3QgbHNtX2lkIHRvbW95b19sc21p ZCBfX2xzbV9yb19hZnRlcl9pbml0ID0gewo+ICsJLmxzbSAgPSAidG9tb3lvIiwKPiArCS5zbG90 ID0gTFNNQkxPQl9OT1RfTkVFREVECj4gK307Cj4gKwo+ICAgLyoKPiAgICAqIHRvbW95b19zZWN1 cml0eV9vcHMgaXMgYSAic3RydWN0IHNlY3VyaXR5X29wZXJhdGlvbnMiIHdoaWNoIGlzIHVzZWQg Zm9yCj4gICAgKiByZWdpc3RlcmluZyBUT01PWU8uCj4gQEAgLTU3Myw3ICs1NzgsOCBAQCBzdGF0 aWMgaW50IF9faW5pdCB0b21veW9faW5pdCh2b2lkKQo+ICAgCXN0cnVjdCB0b21veW9fdGFzayAq cyA9IHRvbW95b190YXNrKGN1cnJlbnQpOwo+ICAgCj4gICAJLyogcmVnaXN0ZXIgb3Vyc2VsdmVz IHdpdGggdGhlIHNlY3VyaXR5IGZyYW1ld29yayAqLwo+IC0Jc2VjdXJpdHlfYWRkX2hvb2tzKHRv bW95b19ob29rcywgQVJSQVlfU0laRSh0b21veW9faG9va3MpLCAidG9tb3lvIik7Cj4gKwlzZWN1 cml0eV9hZGRfaG9va3ModG9tb3lvX2hvb2tzLCBBUlJBWV9TSVpFKHRvbW95b19ob29rcyksCj4g KwkJCSAgICZ0b21veW9fbHNtaWQpOwo+ICAgCXByX2luZm8oIlRPTU9ZTyBMaW51eCBpbml0aWFs aXplZFxuIik7Cj4gICAJcy0+ZG9tYWluX2luZm8gPSAmdG9tb3lvX2tlcm5lbF9kb21haW47Cj4g ICAJYXRvbWljX2luYygmdG9tb3lvX2tlcm5lbF9kb21haW4udXNlcnMpOwo+IGRpZmYgLS1naXQg YS9zZWN1cml0eS95YW1hL3lhbWFfbHNtLmMgYi9zZWN1cml0eS95YW1hL3lhbWFfbHNtLmMKPiBp bmRleCAwNmUyMjYxNjZhYWIuLmE5NjM5ZWE1NDFmNyAxMDA2NDQKPiAtLS0gYS9zZWN1cml0eS95 YW1hL3lhbWFfbHNtLmMKPiArKysgYi9zZWN1cml0eS95YW1hL3lhbWFfbHNtLmMKPiBAQCAtNDIx LDYgKzQyMSwxMSBAQCBzdGF0aWMgaW50IHlhbWFfcHRyYWNlX3RyYWNlbWUoc3RydWN0IHRhc2tf c3RydWN0ICpwYXJlbnQpCj4gICAJcmV0dXJuIHJjOwo+ICAgfQo+ICAgCj4gK3N0YXRpYyBzdHJ1 Y3QgbHNtX2lkIHlhbWFfbHNtaWQgX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKPiArCS5sc20gID0g InlhbWEiLAo+ICsJLnNsb3QgPSBMU01CTE9CX05PVF9ORUVERUQKPiArfTsKPiArCj4gICBzdGF0 aWMgc3RydWN0IHNlY3VyaXR5X2hvb2tfbGlzdCB5YW1hX2hvb2tzW10gX19sc21fcm9fYWZ0ZXJf aW5pdCA9IHsKPiAgIAlMU01fSE9PS19JTklUKHB0cmFjZV9hY2Nlc3NfY2hlY2ssIHlhbWFfcHRy YWNlX2FjY2Vzc19jaGVjayksCj4gICAJTFNNX0hPT0tfSU5JVChwdHJhY2VfdHJhY2VtZSwgeWFt YV9wdHJhY2VfdHJhY2VtZSksCj4gQEAgLTQ3Nyw3ICs0ODIsNyBAQCBzdGF0aWMgaW5saW5lIHZv aWQgeWFtYV9pbml0X3N5c2N0bCh2b2lkKSB7IH0KPiAgIHN0YXRpYyBpbnQgX19pbml0IHlhbWFf aW5pdCh2b2lkKQo+ICAgewo+ICAgCXByX2luZm8oIllhbWE6IGJlY29taW5nIG1pbmRmdWwuXG4i KTsKPiAtCXNlY3VyaXR5X2FkZF9ob29rcyh5YW1hX2hvb2tzLCBBUlJBWV9TSVpFKHlhbWFfaG9v a3MpLCAieWFtYSIpOwo+ICsJc2VjdXJpdHlfYWRkX2hvb2tzKHlhbWFfaG9va3MsIEFSUkFZX1NJ WkUoeWFtYV9ob29rcyksICZ5YW1hX2xzbWlkKTsKPiAgIAl5YW1hX2luaXRfc3lzY3RsKCk7Cj4g ICAJcmV0dXJuIDA7Cj4gICB9CgoKLS0KTGludXgtYXVkaXQgbWFpbGluZyBsaXN0CkxpbnV4LWF1 ZGl0QHJlZGhhdC5jb20KaHR0cHM6Ly9saXN0bWFuLnJlZGhhdC5jb20vbWFpbG1hbi9saXN0aW5m by9saW51eC1hdWRpdA==