From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id A429CC43462 for ; Thu, 13 May 2021 20:10:38 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 71C7E610F8 for ; Thu, 13 May 2021 20:10:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232503AbhEMULq (ORCPT ); Thu, 13 May 2021 16:11:46 -0400 Received: from sonic307-15.consmr.mail.ne1.yahoo.com ([66.163.190.38]:35295 "EHLO sonic307-15.consmr.mail.ne1.yahoo.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232419AbhEMULo (ORCPT ); Thu, 13 May 2021 16:11:44 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=yahoo.com; s=s2048; t=1620936634; bh=xolFaMNvm2tIVaWXyA4u0U8669PmDlk7bKd00ve9fDk=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From:Subject:Reply-To; b=lignkVTJ8dGuQ1J6IRkLpO3kqd+oO7RdZw/yRng5qvpNZqllWyWhxNVkXorE4NSDgoWpuT88tkiQe64uqVD5E/+3qp1ki/Q+MD9B9KSdvQ4ycrDLg+Njo3tTIpZXPkPnnyh/Fjrg5l4dkGQSAHYb1+fCK1umKJKIkBNeDwyn5ILIzeIlBLwX7tKSrthBDYiAHsyJcSonh/+s2WlCCjww5Z0sH4htVg7L28FwK7zS9b0nl/eAnUwIRExy82KtLLOsRwjiz2PJHPH94WFq/45F0ijji8uygVwHTTQg9GMFE5O+cK/sREwx5r4Ywo+JPOCaY4taiMPMDEmakQ19zsR9cQ== X-SONIC-DKIM-SIGN: v=1; a=rsa-sha256; c=relaxed/relaxed; d=yahoo.com; s=s2048; t=1620936634; bh=wR1AnYBj4kPNDmOafcapwAV+hVImkL2ZewE36sYPFp0=; h=X-Sonic-MF:From:To:Subject:Date:From:Subject; b=XtDAAX8xMxJp+bsooiRO0/ythcfNogjAmrOxtRmNRPUCO2nL/pOahJVcnh1xGcPZVGzxiZ/hgaRQs7Ky7wLYj/BTZl19uFJg70F5S3OWHmNVRLkvnf5AtKjOryTLLZtflYz4h+HzRteq6qJrOklqW3R3TTyX9Ut5PqOMPC57FtyNLnISW/hNO8/k8XYGmUEvdjy3oDvJXIoTOKWkdhmeVy6E1mG2Eb/ess0zmsgq252njgrYDbHcxWW9Xb8w/c7saA9FtCsgEmngMmEB1+wgM+SXBM5nqfgp34DkCOC7hLqvMzgaW7E1TlJazvVxYwcwmlSOHP+7FnlrRqmi1vRDKw== X-YMail-OSG: Xy6XT_QVM1n4cVljfSEzVoRj6qUoGo2VupzMWVuccc.w9KDDaaiP46zGuYVqa9Z TyKg2x9VdB8LB8xG6TALsRwBGCgJozFbaHTClM020EuHp77G7IWLivmsHzeyuGDQlgtspjqZjP7C gtGx4jfrdCjwHkJDbUbzTZOSWnyxP_OLpG5AUM71Lk95.7PkU.dHzg1AhGVKFqyc2IK7m914m8Hk nWP9m.NUchOW7A8m92s_Gj_izqY4O6yoRGW7str4umBJXvxWt_vlbAdoHX7eYepHzOzha3ZOEdY9 _4c7KBQ_07eKevL3OHfff2JDRND_nyXpRAmnTw2UNSSGS6_jKzdeZom5nDIVK9xpe083zK0CKN3R 3m9oclH9aJj0Gd9VZozNLnD68X_xRIxDtXsOvr67SE1gBCb1eQEw9.5chp2ONWfwU4grr7Vu_X4q G3Yy.6iCkSyyhzXPdiuSGmSueUU.ye1vnSSQqD_ibSVsRHMtksmTazxAusB4VQd9e1cwrJ0DZroc ROluSk6CHMr.fjD2Yj2WASTyrHs8Gh7.vCpTUxqD.qp3GgdFIqAiQeDwDni0jEHOK7qK7GYatHfr VlQBIe.clJEzhLqgtXCHWrO.wCRAx1eb5EFrCEAZtcZrxPoy0W946LiASuKeiRFEtFfddVSYVjxk 9Top8uMsaEMSaL2jQSEBvAmtJHn7Uhz0MaT6TCwNeOTE339OMtRjoiqdCkvTGEHdAbBGunTMwh5. y43hDyT8.zvRp3yDkj5ERSwkqbTlSK9uLYweUg_S6Scqit.nR.mB2RfYJZt59y.5afRKkobJXGuo lZaNpHimROET0dfz61Bb0jPPXc7fequdTXd0CXBYHx4sv1j_5lA01gcl3YYaQgW5tfBxOXy_eKCM xOqv_cYSJwbwduXPlw7Eno5AvPEO26MV115F3YFjGgyqtNtNqIct71.mYeKqIv78UAjK0yKeMAjZ UJgGlOjk4XFe9HFzPV6Krszu6fJg_nLITlbBWs6aqJibZjm3HT.spTE0JM5P9lYY3KprCgRpEYiY 7uvYtS.brv..Cgnty0CoZ7gz4pU8f09.1qyEsW2PskePFB4KnQGDIhRqdxVbPqaFmAiwYjo3tYzZ 5P9a3iMwoSB58OB0f9fFn1oWufiUSasftSd5e6pfLvFmbVK9NSMfGlIPU1MEdUIxgYInr05YeiP1 1WFJPS4_V1cCR48IeJ7.EJECOBNcZlTWL5FiQ73YxUS4fYBvvgVubKt7c9wR5acvCBNehkrOq0_I i_Zg3DphS0YlrGGCSfvPC8GHh_e0ILHJKBT_9.hDXBSBwzj16bpGezEi1I7RY_zRR.hV3oiSpnBD sjKBQMFpTvEaVFj_PpzILCrFKHoOcOWEWon.0x1I1n2S0q1XGoqXRLcuAk8UJoZe.OZ43333uAZ2 B7RiJ3TPXQaD6n0fRj5YekjuRtbZCE0zsZ4LwwjxN1g1pDruiASMc7.kWfNQ4Fdo6qS2SfR_Uf74 pkT4qC4IA7lASbskrEP8uEN3Q8vDYCmrd48Wl2JW9mVqggI4JVdGpx3kPKUyHkg7RHocMR4yo7hp Eireyy3RCvZBBl3EJP5fqjpOWVfroXL1ZTOfj9SPou00s9Xag7PwBngsUDLh4Kv2OeqhAIPIY65i eIXaMrCYM0tkisjFeYsK3HIkV8T.ojWRq6_FE2CU_ToP4Rj.RcsIUkCf0y4UT7XId2MfIGJZuxVh tCvdD73V7v9NS4nCx63vd2uoPe6xMVuPkr9Qg4IOPQLaSsD73nFaIN.fj4rcslkZh4IzHNQIpuJA LiDO93Hmn30oOTeMcWlZZ.O6WbZpgWe7j9t9hYmKadFItfChZAKfgpCoe6VaF9udwHeHd9L7l1z4 ecJE1snne4_NkEhkCkMWWHmU7BvQZ9nlu7_kMkdDVVHv_pRffxvvvIzlviPPgQjuxTUL63TB4_Sn zhU_cOUyh2SbUIPKnBPJJwTE7r.SLp.254tDoaVUGuY37jKHNk.1KbgVP1asHTLagwsdrxU6UrAy bL18QKLpWQrPsFskyb_gvJKkZFyiKtn_p5OQbw2UVaeK1xOZ3akAjHI9dbBlpG1Qlv_rb6lBsP7o r3sou34DLessM50vA7MkBsEevFNMp3twJCu_bLUAXhZ_Y5f5GFOHtve0Msq6xG6rfH19gyqfoSIJ E4h03gTHUhKwwC4wU.DXdhoYCgPyBO6iz9l.e0o4m5sUKuqTJ9JHSIbJZn_bLYT7MP.q7fIHJHHe TryIHKvyS2B_PUnpoiqFtGIc6Ew3YMl.BH_wIujghqeYtSoFOxy71QWH2j8PyNAIKwM0pxN9yNo. NKJP_Z2Ni6zYzVklIc1f_aJ80t1FYST5r.3Cj4aavFZjXaQ3Gx1L0OCJ.PpFB7kh482j9Iu0Vo.C cd_Hf9DRISBzzJB3AEhliaYAIymFSO_6E4NAM7Vxe4rxabVh08vqMIhMQQMblGwsThExUvyQUZTJ x6DOzFAf7jAlnYM.wM29KN.2z2I_vmSGEhFcou9KGsfj2J0QujoLHvlkzIzpdabg_mEfKTTVS8V1 hRh_EwF880uFcQjxBp0fUK6CMJwMlHDSHgAp5AIJiYI4ctMBdttaX79UXTMvnZPDIzROlArtSkSs TqLiA98g3WH8qs7NdPPO0BfUYWopdwE0gri3HItES_0CcDlDlwKokBBk4WiuZBzsqMprsjQhTtho Ct5PTfYzcVMZLuMK6XtwiJM3j.Va9yn1_eN86q_.qB4f_2ZromakLI8ZxP7ye_1if13Fa0ll3TuI dZg7skemTrH72o4rulfnPkrlSWmsv3TsvZltKAGhCE6P0OZVAZNExrjflkwDkZbw8IvgbkWDxKgC YLr6kcVugP32THqT_6TWk_FRfQZ2hk5PEKNqUZsm95t8rSKBfFV8nUdFnPSuhQFZXKOkm4rkbFX5 inrrdVrWyMnpEinmulyEoqHrvBXTwkJNbP_yCYCQVvdsA.TENRzzML3HDqaHDA27XytOtp.X0K.7 XxqgrgbEq7g0S0F07iL7Y2i_VdEHFO3S2eErys9vqyZ4A8RwQKqOLq0Gl2xGTjGGMdZW.LybX2me kRp9V06TsIN_ZtfUOZ5FwC3.cNDGMo4kxnUHKwACmBYS_mEsLRPdxFWCk1CE5B0jijuZ_puEQhba HyTJuMFfiwdKw8azHi8zbJJ0HtZmnD1bLa1pdMvWz9yYiN1iPvlztTwq7ZOWAb9gDYQs6gCu7I3Y - X-Sonic-MF: Received: from sonic.gate.mail.ne1.yahoo.com by sonic307.consmr.mail.ne1.yahoo.com with HTTP; Thu, 13 May 2021 20:10:34 +0000 Received: by kubenode512.mail-prod1.omega.bf1.yahoo.com (VZM Hermes SMTP Server) with ESMTPA ID c571e24bb6d9bd02ecd96e3664e8c071; Thu, 13 May 2021 20:10:29 +0000 (UTC) From: Casey Schaufler To: casey.schaufler@intel.com, jmorris@namei.org, linux-security-module@vger.kernel.org, selinux@vger.kernel.org Cc: casey@schaufler-ca.com, 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, bpf@vger.kernel.org Subject: [PATCH v26 02/25] LSM: Add the lsmblob data structure. Date: Thu, 13 May 2021 13:07:44 -0700 Message-Id: <20210513200807.15910-3-casey@schaufler-ca.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20210513200807.15910-1-casey@schaufler-ca.com> References: <20210513200807.15910-1-casey@schaufler-ca.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 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. Because IMA uses the audit rule functions it is affected as well. Acked-by: Stephen Smalley Acked-by: Paul Moore Acked-by: John Johansen Signed-off-by: Casey Schaufler Cc: Cc: linux-audit@redhat.com Cc: linux-security-module@vger.kernel.org Cc: selinux@vger.kernel.org To: Mimi Zohar To: Mickaël Salaün --- include/linux/audit.h | 4 +- include/linux/lsm_hooks.h | 12 ++++- include/linux/security.h | 67 +++++++++++++++++++++++++-- kernel/auditfilter.c | 24 +++++----- kernel/auditsc.c | 13 +++--- security/apparmor/lsm.c | 7 ++- security/bpf/hooks.c | 12 ++++- security/commoncap.c | 7 ++- security/integrity/ima/ima_policy.c | 40 +++++++++++----- security/landlock/cred.c | 2 +- security/landlock/fs.c | 2 +- security/landlock/ptrace.c | 2 +- security/landlock/setup.c | 4 ++ security/landlock/setup.h | 1 + security/loadpin/loadpin.c | 8 +++- security/lockdown/lockdown.c | 7 ++- security/safesetid/lsm.c | 8 +++- security/security.c | 72 ++++++++++++++++++++++++----- security/selinux/hooks.c | 8 +++- security/smack/smack_lsm.c | 7 ++- security/tomoyo/tomoyo.c | 8 +++- security/yama/yama_lsm.c | 7 ++- 22 files changed, 262 insertions(+), 60 deletions(-) diff --git a/include/linux/audit.h b/include/linux/audit.h index 82b7c1116a85..418a485af114 100644 --- a/include/linux/audit.h +++ b/include/linux/audit.h @@ -11,6 +11,7 @@ #include #include +#include #include #include @@ -65,8 +66,9 @@ struct audit_field { kuid_t uid; kgid_t gid; struct { + bool lsm_isset; char *lsm_str; - void *lsm_rule; + void *lsm_rules[LSMBLOB_ENTRIES]; }; }; u32 op; diff --git a/include/linux/lsm_hooks.h b/include/linux/lsm_hooks.h index afd3b16875b0..c61a16f0a5bc 100644 --- a/include/linux/lsm_hooks.h +++ b/include/linux/lsm_hooks.h @@ -1570,6 +1570,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. @@ -1578,7 +1586,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; /* @@ -1614,7 +1622,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 06f7c50ce77f..62588bc522ba 100644 --- a/include/linux/security.h +++ b/include/linux/security.h @@ -133,6 +133,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 + * @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 = {}; + + 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) +{ + 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); @@ -1881,8 +1940,8 @@ static inline int security_key_getsecurity(struct key *key, char **_buffer) #ifdef CONFIG_SECURITY int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule); 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, void **lsmrule); +void security_audit_rule_free(void **lsmrule); #else @@ -1898,12 +1957,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) + void **lsmrule) { return 0; } -static inline void security_audit_rule_free(void *lsmrule) +static inline void security_audit_rule_free(void **lsmrule) { } #endif /* CONFIG_SECURITY */ diff --git a/kernel/auditfilter.c b/kernel/auditfilter.c index db2c6b59dfc3..a2340e81cfa7 100644 --- a/kernel/auditfilter.c +++ b/kernel/auditfilter.c @@ -74,7 +74,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); } } @@ -519,9 +519,10 @@ static struct audit_entry *audit_data_to_entry(struct audit_rule_data *data, goto exit_free; } entry->rule.buflen += f_val; + f->lsm_isset = true; 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) { @@ -774,7 +775,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) @@ -788,9 +789,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) { @@ -842,7 +843,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) { @@ -1358,11 +1359,12 @@ 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_isset) { security_task_getsecid_subj(current, &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: @@ -1389,7 +1391,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; @@ -1421,7 +1423,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 @@ -1436,7 +1438,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 175ef6f3ea4e..392afe3e2fd6 100644 --- a/kernel/auditsc.c +++ b/kernel/auditsc.c @@ -665,14 +665,13 @@ 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_isset) { if (need_sid) { security_task_getsecid_subj(tsk, &sid); 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: @@ -682,21 +681,21 @@ 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_isset) { /* 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)) { + f->lsm_rules)) { ++result; break; } @@ -707,7 +706,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 4113516fb62e..392e25940d1f 100644 --- a/security/apparmor/lsm.c +++ b/security/apparmor/lsm.c @@ -1161,6 +1161,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), @@ -1862,7 +1867,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 3f810d37b71b..628685cf20e3 100644 --- a/security/commoncap.c +++ b/security/commoncap.c @@ -1443,6 +1443,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), @@ -1467,7 +1472,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/integrity/ima/ima_policy.c b/security/integrity/ima/ima_policy.c index fd5d46e511f1..5c40677e881c 100644 --- a/security/integrity/ima/ima_policy.c +++ b/security/integrity/ima/ima_policy.c @@ -80,7 +80,7 @@ struct ima_rule_entry { bool (*fowner_op)(kuid_t, kuid_t); /* uid_eq(), uid_gt(), uid_lt() */ int pcr; struct { - void *rule; /* LSM file metadata specific */ + void *rules[LSMBLOB_ENTRIES]; /* LSM file metadata specific */ char *args_p; /* audit value */ int type; /* audit type */ } lsm[MAX_LSM_RULES]; @@ -90,6 +90,22 @@ struct ima_rule_entry { struct ima_template_desc *template; }; +/** + * ima_lsm_isset - Is a rule set for any of the active security modules + * @rules: The set of IMA rules to check + * + * If a rule is set for any LSM return true, otherwise return false. + */ +static inline bool ima_lsm_isset(void *rules[]) +{ + int i; + + for (i = 0; i < LSMBLOB_ENTRIES; i++) + if (rules[i]) + return true; + return false; +} + /* * Without LSM specific knowledge, the default policy can only be * written in terms of .action, .func, .mask, .fsmagic, .uid, and .fowner @@ -335,9 +351,11 @@ static void ima_free_rule_opt_list(struct ima_rule_opt_list *opt_list) static void ima_lsm_free_rule(struct ima_rule_entry *entry) { int i; + int r; for (i = 0; i < MAX_LSM_RULES; i++) { - ima_filter_rule_free(entry->lsm[i].rule); + for (r = 0; r < LSMBLOB_ENTRIES; r++) + ima_filter_rule_free(entry->lsm[i].rules[r]); kfree(entry->lsm[i].args_p); } } @@ -388,8 +406,8 @@ static struct ima_rule_entry *ima_lsm_copy_rule(struct ima_rule_entry *entry) ima_filter_rule_init(nentry->lsm[i].type, Audit_equal, nentry->lsm[i].args_p, - &nentry->lsm[i].rule); - if (!nentry->lsm[i].rule) + &nentry->lsm[i].rules[0]); + if (!ima_lsm_isset(nentry->lsm[i].rules)) pr_warn("rule for LSM \'%s\' is undefined\n", nentry->lsm[i].args_p); } @@ -578,7 +596,7 @@ static bool ima_match_rules(struct ima_rule_entry *rule, int rc = 0; u32 osid; - if (!rule->lsm[i].rule) { + if (!ima_lsm_isset(rule->lsm[i].rules)) { if (!rule->lsm[i].args_p) continue; else @@ -591,14 +609,14 @@ static bool ima_match_rules(struct ima_rule_entry *rule, security_inode_getsecid(inode, &osid); rc = ima_filter_rule_match(osid, rule->lsm[i].type, Audit_equal, - rule->lsm[i].rule); + rule->lsm[i].rules); break; case LSM_SUBJ_USER: case LSM_SUBJ_ROLE: case LSM_SUBJ_TYPE: rc = ima_filter_rule_match(secid, rule->lsm[i].type, Audit_equal, - rule->lsm[i].rule); + rule->lsm[i].rules); break; default: break; @@ -994,7 +1012,7 @@ static int ima_lsm_rule_init(struct ima_rule_entry *entry, { int result; - if (entry->lsm[lsm_rule].rule) + if (ima_lsm_isset(entry->lsm[lsm_rule].rules)) return -EINVAL; entry->lsm[lsm_rule].args_p = match_strdup(args); @@ -1004,8 +1022,8 @@ static int ima_lsm_rule_init(struct ima_rule_entry *entry, entry->lsm[lsm_rule].type = audit_type; result = ima_filter_rule_init(entry->lsm[lsm_rule].type, Audit_equal, entry->lsm[lsm_rule].args_p, - &entry->lsm[lsm_rule].rule); - if (!entry->lsm[lsm_rule].rule) { + &entry->lsm[lsm_rule].rules[0]); + if (!ima_lsm_isset(entry->lsm[lsm_rule].rules)) { pr_warn("rule for LSM \'%s\' is undefined\n", entry->lsm[lsm_rule].args_p); @@ -1812,7 +1830,7 @@ int ima_policy_show(struct seq_file *m, void *v) } for (i = 0; i < MAX_LSM_RULES; i++) { - if (entry->lsm[i].rule) { + if (ima_lsm_isset(entry->lsm[i].rules)) { switch (i) { case LSM_OBJ_USER: seq_printf(m, pt(Opt_obj_user), 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..4a12666a4090 100644 --- a/security/landlock/setup.c +++ b/security/landlock/setup.c @@ -23,6 +23,10 @@ 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, +}; + 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 1079c6d54784..a2a2f462a821 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 e12a7c463468..a3276deb1b8a 100644 --- a/security/security.c +++ b/security/security.c @@ -344,6 +344,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 @@ -471,21 +472,36 @@ 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; + 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); } @@ -494,7 +510,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__); } } @@ -2070,7 +2086,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); } @@ -2083,7 +2099,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); } @@ -2576,7 +2592,24 @@ int security_key_getsecurity(struct key *key, char **_buffer) int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule) { - 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, + &lsmrule[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) @@ -2584,14 +2617,31 @@ 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(void **lsmrule) { - 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; + hp->hook.audit_rule_free(lsmrule[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, void **lsmrule) { - 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; + rc = hp->hook.audit_rule_match(secid, field, op, + &lsmrule[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 84ddcec6322e..0133b142e938 100644 --- a/security/selinux/hooks.c +++ b/security/selinux/hooks.c @@ -7111,6 +7111,11 @@ static int selinux_perf_event_write(struct perf_event *event) } #endif +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, @@ -7424,7 +7429,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 1ee0bf1493f6..5c10ad27be37 100644 --- a/security/smack/smack_lsm.c +++ b/security/smack/smack_lsm.c @@ -4694,6 +4694,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), @@ -4893,7 +4898,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 1f3cd432d830..22f62c67f2ec 100644 --- a/security/tomoyo/tomoyo.c +++ b/security/tomoyo/tomoyo.c @@ -523,6 +523,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. @@ -575,7 +580,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; } -- 2.29.2 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7B3FCC433B4 for ; Thu, 13 May 2021 20:10:50 +0000 (UTC) Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id D3B606143C for ; Thu, 13 May 2021 20:10:49 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D3B606143C Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=schaufler-ca.com Authentication-Results: mail.kernel.org; spf=tempfail smtp.mailfrom=linux-audit-bounces@redhat.com Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-292-c7HVHjX0MPu1l9Zg8kusSw-1; Thu, 13 May 2021 16:10:46 -0400 X-MC-Unique: c7HVHjX0MPu1l9Zg8kusSw-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 D718A8005AD; Thu, 13 May 2021 20:10:43 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id B167B6787D; Thu, 13 May 2021 20:10:43 +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 8030018005B6; Thu, 13 May 2021 20:10:43 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.rdu2.redhat.com [10.11.54.3]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 14DKAeJu021266 for ; Thu, 13 May 2021 16:10:40 -0400 Received: by smtp.corp.redhat.com (Postfix) id 3722310CB27F; Thu, 13 May 2021 20:10:40 +0000 (UTC) Received: from mimecast-mx02.redhat.com (mimecast02.extmail.prod.ext.rdu2.redhat.com [10.11.55.18]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 3284B10CB283 for ; Thu, 13 May 2021 20:10:37 +0000 (UTC) Received: from us-smtp-1.mimecast.com (us-smtp-1.mimecast.com [205.139.110.61]) (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 265B6800B29 for ; Thu, 13 May 2021 20:10:37 +0000 (UTC) Received: from sonic307-15.consmr.mail.ne1.yahoo.com (sonic307-15.consmr.mail.ne1.yahoo.com [66.163.190.38]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-240-BCS3bM2UPCGcJr0M2ZtP_w-1; Thu, 13 May 2021 16:10:34 -0400 X-MC-Unique: BCS3bM2UPCGcJr0M2ZtP_w-1 X-SONIC-DKIM-SIGN: v=1; a=rsa-sha256; c=relaxed/relaxed; d=yahoo.com; s=s2048; t=1620936634; bh=wR1AnYBj4kPNDmOafcapwAV+hVImkL2ZewE36sYPFp0=; h=X-Sonic-MF:From:To:Subject:Date:From:Subject; b=XtDAAX8xMxJp+bsooiRO0/ythcfNogjAmrOxtRmNRPUCO2nL/pOahJVcnh1xGcPZVGzxiZ/hgaRQs7Ky7wLYj/BTZl19uFJg70F5S3OWHmNVRLkvnf5AtKjOryTLLZtflYz4h+HzRteq6qJrOklqW3R3TTyX9Ut5PqOMPC57FtyNLnISW/hNO8/k8XYGmUEvdjy3oDvJXIoTOKWkdhmeVy6E1mG2Eb/ess0zmsgq252njgrYDbHcxWW9Xb8w/c7saA9FtCsgEmngMmEB1+wgM+SXBM5nqfgp34DkCOC7hLqvMzgaW7E1TlJazvVxYwcwmlSOHP+7FnlrRqmi1vRDKw== X-YMail-OSG: Xy6XT_QVM1n4cVljfSEzVoRj6qUoGo2VupzMWVuccc.w9KDDaaiP46zGuYVqa9Z TyKg2x9VdB8LB8xG6TALsRwBGCgJozFbaHTClM020EuHp77G7IWLivmsHzeyuGDQlgtspjqZjP7C gtGx4jfrdCjwHkJDbUbzTZOSWnyxP_OLpG5AUM71Lk95.7PkU.dHzg1AhGVKFqyc2IK7m914m8Hk nWP9m.NUchOW7A8m92s_Gj_izqY4O6yoRGW7str4umBJXvxWt_vlbAdoHX7eYepHzOzha3ZOEdY9 _4c7KBQ_07eKevL3OHfff2JDRND_nyXpRAmnTw2UNSSGS6_jKzdeZom5nDIVK9xpe083zK0CKN3R 3m9oclH9aJj0Gd9VZozNLnD68X_xRIxDtXsOvr67SE1gBCb1eQEw9.5chp2ONWfwU4grr7Vu_X4q G3Yy.6iCkSyyhzXPdiuSGmSueUU.ye1vnSSQqD_ibSVsRHMtksmTazxAusB4VQd9e1cwrJ0DZroc ROluSk6CHMr.fjD2Yj2WASTyrHs8Gh7.vCpTUxqD.qp3GgdFIqAiQeDwDni0jEHOK7qK7GYatHfr VlQBIe.clJEzhLqgtXCHWrO.wCRAx1eb5EFrCEAZtcZrxPoy0W946LiASuKeiRFEtFfddVSYVjxk 9Top8uMsaEMSaL2jQSEBvAmtJHn7Uhz0MaT6TCwNeOTE339OMtRjoiqdCkvTGEHdAbBGunTMwh5. y43hDyT8.zvRp3yDkj5ERSwkqbTlSK9uLYweUg_S6Scqit.nR.mB2RfYJZt59y.5afRKkobJXGuo lZaNpHimROET0dfz61Bb0jPPXc7fequdTXd0CXBYHx4sv1j_5lA01gcl3YYaQgW5tfBxOXy_eKCM xOqv_cYSJwbwduXPlw7Eno5AvPEO26MV115F3YFjGgyqtNtNqIct71.mYeKqIv78UAjK0yKeMAjZ UJgGlOjk4XFe9HFzPV6Krszu6fJg_nLITlbBWs6aqJibZjm3HT.spTE0JM5P9lYY3KprCgRpEYiY 7uvYtS.brv..Cgnty0CoZ7gz4pU8f09.1qyEsW2PskePFB4KnQGDIhRqdxVbPqaFmAiwYjo3tYzZ 5P9a3iMwoSB58OB0f9fFn1oWufiUSasftSd5e6pfLvFmbVK9NSMfGlIPU1MEdUIxgYInr05YeiP1 1WFJPS4_V1cCR48IeJ7.EJECOBNcZlTWL5FiQ73YxUS4fYBvvgVubKt7c9wR5acvCBNehkrOq0_I i_Zg3DphS0YlrGGCSfvPC8GHh_e0ILHJKBT_9.hDXBSBwzj16bpGezEi1I7RY_zRR.hV3oiSpnBD sjKBQMFpTvEaVFj_PpzILCrFKHoOcOWEWon.0x1I1n2S0q1XGoqXRLcuAk8UJoZe.OZ43333uAZ2 B7RiJ3TPXQaD6n0fRj5YekjuRtbZCE0zsZ4LwwjxN1g1pDruiASMc7.kWfNQ4Fdo6qS2SfR_Uf74 pkT4qC4IA7lASbskrEP8uEN3Q8vDYCmrd48Wl2JW9mVqggI4JVdGpx3kPKUyHkg7RHocMR4yo7hp Eireyy3RCvZBBl3EJP5fqjpOWVfroXL1ZTOfj9SPou00s9Xag7PwBngsUDLh4Kv2OeqhAIPIY65i eIXaMrCYM0tkisjFeYsK3HIkV8T.ojWRq6_FE2CU_ToP4Rj.RcsIUkCf0y4UT7XId2MfIGJZuxVh tCvdD73V7v9NS4nCx63vd2uoPe6xMVuPkr9Qg4IOPQLaSsD73nFaIN.fj4rcslkZh4IzHNQIpuJA LiDO93Hmn30oOTeMcWlZZ.O6WbZpgWe7j9t9hYmKadFItfChZAKfgpCoe6VaF9udwHeHd9L7l1z4 ecJE1snne4_NkEhkCkMWWHmU7BvQZ9nlu7_kMkdDVVHv_pRffxvvvIzlviPPgQjuxTUL63TB4_Sn zhU_cOUyh2SbUIPKnBPJJwTE7r.SLp.254tDoaVUGuY37jKHNk.1KbgVP1asHTLagwsdrxU6UrAy bL18QKLpWQrPsFskyb_gvJKkZFyiKtn_p5OQbw2UVaeK1xOZ3akAjHI9dbBlpG1Qlv_rb6lBsP7o r3sou34DLessM50vA7MkBsEevFNMp3twJCu_bLUAXhZ_Y5f5GFOHtve0Msq6xG6rfH19gyqfoSIJ E4h03gTHUhKwwC4wU.DXdhoYCgPyBO6iz9l.e0o4m5sUKuqTJ9JHSIbJZn_bLYT7MP.q7fIHJHHe TryIHKvyS2B_PUnpoiqFtGIc6Ew3YMl.BH_wIujghqeYtSoFOxy71QWH2j8PyNAIKwM0pxN9yNo. NKJP_Z2Ni6zYzVklIc1f_aJ80t1FYST5r.3Cj4aavFZjXaQ3Gx1L0OCJ.PpFB7kh482j9Iu0Vo.C cd_Hf9DRISBzzJB3AEhliaYAIymFSO_6E4NAM7Vxe4rxabVh08vqMIhMQQMblGwsThExUvyQUZTJ x6DOzFAf7jAlnYM.wM29KN.2z2I_vmSGEhFcou9KGsfj2J0QujoLHvlkzIzpdabg_mEfKTTVS8V1 hRh_EwF880uFcQjxBp0fUK6CMJwMlHDSHgAp5AIJiYI4ctMBdttaX79UXTMvnZPDIzROlArtSkSs TqLiA98g3WH8qs7NdPPO0BfUYWopdwE0gri3HItES_0CcDlDlwKokBBk4WiuZBzsqMprsjQhTtho Ct5PTfYzcVMZLuMK6XtwiJM3j.Va9yn1_eN86q_.qB4f_2ZromakLI8ZxP7ye_1if13Fa0ll3TuI dZg7skemTrH72o4rulfnPkrlSWmsv3TsvZltKAGhCE6P0OZVAZNExrjflkwDkZbw8IvgbkWDxKgC YLr6kcVugP32THqT_6TWk_FRfQZ2hk5PEKNqUZsm95t8rSKBfFV8nUdFnPSuhQFZXKOkm4rkbFX5 inrrdVrWyMnpEinmulyEoqHrvBXTwkJNbP_yCYCQVvdsA.TENRzzML3HDqaHDA27XytOtp.X0K.7 XxqgrgbEq7g0S0F07iL7Y2i_VdEHFO3S2eErys9vqyZ4A8RwQKqOLq0Gl2xGTjGGMdZW.LybX2me kRp9V06TsIN_ZtfUOZ5FwC3.cNDGMo4kxnUHKwACmBYS_mEsLRPdxFWCk1CE5B0jijuZ_puEQhba HyTJuMFfiwdKw8azHi8zbJJ0HtZmnD1bLa1pdMvWz9yYiN1iPvlztTwq7ZOWAb9gDYQs6gCu7I3Y - X-Sonic-MF: Received: from sonic.gate.mail.ne1.yahoo.com by sonic307.consmr.mail.ne1.yahoo.com with HTTP; Thu, 13 May 2021 20:10:34 +0000 Received: by kubenode512.mail-prod1.omega.bf1.yahoo.com (VZM Hermes SMTP Server) with ESMTPA ID c571e24bb6d9bd02ecd96e3664e8c071; Thu, 13 May 2021 20:10:29 +0000 (UTC) From: Casey Schaufler To: casey.schaufler@intel.com, jmorris@namei.org, linux-security-module@vger.kernel.org, selinux@vger.kernel.org Subject: [PATCH v26 02/25] LSM: Add the lsmblob data structure. Date: Thu, 13 May 2021 13:07:44 -0700 Message-Id: <20210513200807.15910-3-casey@schaufler-ca.com> In-Reply-To: <20210513200807.15910-1-casey@schaufler-ca.com> References: <20210513200807.15910-1-casey@schaufler-ca.com> MIME-Version: 1.0 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.78 on 10.11.54.3 X-loop: linux-audit@redhat.com Cc: john.johansen@canonical.com, linux-kernel@vger.kernel.org, linux-audit@redhat.com, bpf@vger.kernel.org, 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-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 V2hlbiBtb3JlIHRoYW4gb25lIHNlY3VyaXR5IG1vZHVsZSBpcyBleHBvcnRpbmcgZGF0YSB0bwph dWRpdCBhbmQgbmV0d29ya2luZyBzdWItc3lzdGVtcyBhIHNpbmdsZSAzMiBiaXQgaW50ZWdlcgpp cyBubyBsb25nZXIgc3VmZmljaWVudCB0byByZXByZXNlbnQgdGhlIGRhdGEuIEFkZCBhCnN0cnVj dHVyZSB0byBiZSB1c2VkIGluc3RlYWQuCgpUaGUgbHNtYmxvYiBzdHJ1Y3R1cmUgaXMgY3VycmVu dGx5IGFuIGFycmF5IG9mCnUzMiAic2VjaWRzIi4gVGhlcmUgaXMgYW4gZW50cnkgZm9yIGVhY2gg b2YgdGhlCnNlY3VyaXR5IG1vZHVsZXMgYnVpbHQgaW50byB0aGUgc3lzdGVtIHRoYXQgd291bGQK dXNlIHNlY2lkcyBpZiBhY3RpdmUuIFRoZSBzeXN0ZW0gYXNzaWducyB0aGUgbW9kdWxlCmEgInNs b3QiIHdoZW4gaXQgcmVnaXN0ZXJzIGhvb2tzLiBJZiBtb2R1bGVzIGFyZQpjb21waWxlZCBpbiBi dXQgbm90IHJlZ2lzdGVyZWQgdGhlcmUgd2lsbCBiZSB1bnVzZWQKc2xvdHMuCgpBIG5ldyBsc21f aWQgc3RydWN0dXJlLCB3aGljaCBjb250YWlucyB0aGUgbmFtZQpvZiB0aGUgTFNNIGFuZCBpdHMg c2xvdCBudW1iZXIsIGlzIGNyZWF0ZWQuIFRoZXJlCmlzIGFuIGluc3RhbmNlIGZvciBlYWNoIExT TSwgd2hpY2ggYXNzaWducyB0aGUgbmFtZQphbmQgcGFzc2VzIGl0IHRvIHRoZSBpbmZyYXN0cnVj dHVyZSB0byBzZXQgdGhlIHNsb3QuCgpUaGUgYXVkaXQgcnVsZXMgZGF0YSBpcyBleHBhbmRlZCB0 byB1c2UgYW4gYXJyYXkgb2YKc2VjdXJpdHkgbW9kdWxlIGRhdGEgcmF0aGVyIHRoYW4gYSBzaW5n bGUgaW5zdGFuY2UuCkJlY2F1c2UgSU1BIHVzZXMgdGhlIGF1ZGl0IHJ1bGUgZnVuY3Rpb25zIGl0 IGlzCmFmZmVjdGVkIGFzIHdlbGwuCgpBY2tlZC1ieTogU3RlcGhlbiBTbWFsbGV5IDxzZHNAdHlj aG8ubnNhLmdvdj4KQWNrZWQtYnk6IFBhdWwgTW9vcmUgPHBhdWxAcGF1bC1tb29yZS5jb20+CkFj a2VkLWJ5OiBKb2huIEpvaGFuc2VuIDxqb2huLmpvaGFuc2VuQGNhbm9uaWNhbC5jb20+ClNpZ25l ZC1vZmYtYnk6IENhc2V5IFNjaGF1ZmxlciA8Y2FzZXlAc2NoYXVmbGVyLWNhLmNvbT4KQ2M6IDxi cGZAdmdlci5rZXJuZWwub3JnPgpDYzogbGludXgtYXVkaXRAcmVkaGF0LmNvbQpDYzogbGludXgt c2VjdXJpdHktbW9kdWxlQHZnZXIua2VybmVsLm9yZwpDYzogc2VsaW51eEB2Z2VyLmtlcm5lbC5v cmcKVG86IE1pbWkgWm9oYXIgPHpvaGFyQGxpbnV4LmlibS5jb20+ClRvOiBNaWNrYcOrbCBTYWxh w7xuIDxtaWNAbGludXgubWljcm9zb2Z0LmNvbT4KLS0tCiBpbmNsdWRlL2xpbnV4L2F1ZGl0Lmgg ICAgICAgICAgICAgICB8ICA0ICstCiBpbmNsdWRlL2xpbnV4L2xzbV9ob29rcy5oICAgICAgICAg ICB8IDEyICsrKystCiBpbmNsdWRlL2xpbnV4L3NlY3VyaXR5LmggICAgICAgICAgICB8IDY3ICsr KysrKysrKysrKysrKysrKysrKysrKystLQoga2VybmVsL2F1ZGl0ZmlsdGVyLmMgICAgICAgICAg ICAgICAgfCAyNCArKysrKy0tLS0tCiBrZXJuZWwvYXVkaXRzYy5jICAgICAgICAgICAgICAgICAg ICB8IDEzICsrKy0tLQogc2VjdXJpdHkvYXBwYXJtb3IvbHNtLmMgICAgICAgICAgICAgfCAgNyAr Ky0KIHNlY3VyaXR5L2JwZi9ob29rcy5jICAgICAgICAgICAgICAgIHwgMTIgKysrKy0KIHNlY3Vy aXR5L2NvbW1vbmNhcC5jICAgICAgICAgICAgICAgIHwgIDcgKystCiBzZWN1cml0eS9pbnRlZ3Jp dHkvaW1hL2ltYV9wb2xpY3kuYyB8IDQwICsrKysrKysrKysrLS0tLS0KIHNlY3VyaXR5L2xhbmRs b2NrL2NyZWQuYyAgICAgICAgICAgIHwgIDIgKy0KIHNlY3VyaXR5L2xhbmRsb2NrL2ZzLmMgICAg ICAgICAgICAgIHwgIDIgKy0KIHNlY3VyaXR5L2xhbmRsb2NrL3B0cmFjZS5jICAgICAgICAgIHwg IDIgKy0KIHNlY3VyaXR5L2xhbmRsb2NrL3NldHVwLmMgICAgICAgICAgIHwgIDQgKysKIHNlY3Vy aXR5L2xhbmRsb2NrL3NldHVwLmggICAgICAgICAgIHwgIDEgKwogc2VjdXJpdHkvbG9hZHBpbi9s b2FkcGluLmMgICAgICAgICAgfCAgOCArKystCiBzZWN1cml0eS9sb2NrZG93bi9sb2NrZG93bi5j ICAgICAgICB8ICA3ICsrLQogc2VjdXJpdHkvc2FmZXNldGlkL2xzbS5jICAgICAgICAgICAgfCAg OCArKystCiBzZWN1cml0eS9zZWN1cml0eS5jICAgICAgICAgICAgICAgICB8IDcyICsrKysrKysr KysrKysrKysrKysrKysrKy0tLS0tCiBzZWN1cml0eS9zZWxpbnV4L2hvb2tzLmMgICAgICAgICAg ICB8ICA4ICsrKy0KIHNlY3VyaXR5L3NtYWNrL3NtYWNrX2xzbS5jICAgICAgICAgIHwgIDcgKyst CiBzZWN1cml0eS90b21veW8vdG9tb3lvLmMgICAgICAgICAgICB8ICA4ICsrKy0KIHNlY3VyaXR5 L3lhbWEveWFtYV9sc20uYyAgICAgICAgICAgIHwgIDcgKystCiAyMiBmaWxlcyBjaGFuZ2VkLCAy NjIgaW5zZXJ0aW9ucygrKSwgNjAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9s aW51eC9hdWRpdC5oIGIvaW5jbHVkZS9saW51eC9hdWRpdC5oCmluZGV4IDgyYjdjMTExNmE4NS4u NDE4YTQ4NWFmMTE0IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2F1ZGl0LmgKKysrIGIvaW5j bHVkZS9saW51eC9hdWRpdC5oCkBAIC0xMSw2ICsxMSw3IEBACiAKICNpbmNsdWRlIDxsaW51eC9z Y2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3B0cmFjZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NlY3Vy aXR5Lmg+CiAjaW5jbHVkZSA8dWFwaS9saW51eC9hdWRpdC5oPgogI2luY2x1ZGUgPHVhcGkvbGlu dXgvbmV0ZmlsdGVyL25mX3RhYmxlcy5oPgogCkBAIC02NSw4ICs2Niw5IEBAIHN0cnVjdCBhdWRp dF9maWVsZCB7CiAJCWt1aWRfdAkJCXVpZDsKIAkJa2dpZF90CQkJZ2lkOwogCQlzdHJ1Y3Qgewor CQkJYm9vbAkJbHNtX2lzc2V0OwogCQkJY2hhcgkJKmxzbV9zdHI7Ci0JCQl2b2lkCQkqbHNtX3J1 bGU7CisJCQl2b2lkCQkqbHNtX3J1bGVzW0xTTUJMT0JfRU5UUklFU107CiAJCX07CiAJfTsKIAl1 MzIJCQkJb3A7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2xzbV9ob29rcy5oIGIvaW5jbHVk ZS9saW51eC9sc21faG9va3MuaAppbmRleCBhZmQzYjE2ODc1YjAuLmM2MWExNmYwYTViYyAxMDA2 NDQKLS0tIGEvaW5jbHVkZS9saW51eC9sc21faG9va3MuaAorKysgYi9pbmNsdWRlL2xpbnV4L2xz bV9ob29rcy5oCkBAIC0xNTcwLDYgKzE1NzAsMTQgQEAgc3RydWN0IHNlY3VyaXR5X2hvb2tfaGVh ZHMgewogCSN1bmRlZiBMU01fSE9PSwogfSBfX3JhbmRvbWl6ZV9sYXlvdXQ7CiAKKy8qCisgKiBJ bmZvcm1hdGlvbiB0aGF0IGlkZW50aWZpZXMgYSBzZWN1cml0eSBtb2R1bGUuCisgKi8KK3N0cnVj dCBsc21faWQgeworCWNvbnN0IGNoYXIJKmxzbTsJLyogTmFtZSBvZiB0aGUgTFNNICovCisJaW50 CQlzbG90OwkvKiBTbG90IGluIGxzbWJsb2IgaWYgb25lIGlzIGFsbG9jYXRlZCAqLworfTsKKwog LyoKICAqIFNlY3VyaXR5IG1vZHVsZSBob29rIGxpc3Qgc3RydWN0dXJlLgogICogRm9yIHVzZSB3 aXRoIGdlbmVyaWMgbGlzdCBtYWNyb3MgZm9yIGNvbW1vbiBvcGVyYXRpb25zLgpAQCAtMTU3OCw3 ICsxNTg2LDcgQEAgc3RydWN0IHNlY3VyaXR5X2hvb2tfbGlzdCB7CiAJc3RydWN0IGhsaXN0X25v ZGUJCWxpc3Q7CiAJc3RydWN0IGhsaXN0X2hlYWQJCSpoZWFkOwogCXVuaW9uIHNlY3VyaXR5X2xp c3Rfb3B0aW9ucwlob29rOwotCWNoYXIJCQkJKmxzbTsKKwlzdHJ1Y3QgbHNtX2lkCQkJKmxzbWlk OwogfSBfX3JhbmRvbWl6ZV9sYXlvdXQ7CiAKIC8qCkBAIC0xNjE0LDcgKzE2MjIsNyBAQCBleHRl cm4gc3RydWN0IHNlY3VyaXR5X2hvb2tfaGVhZHMgc2VjdXJpdHlfaG9va19oZWFkczsKIGV4dGVy biBjaGFyICpsc21fbmFtZXM7CiAKIGV4dGVybiB2b2lkIHNlY3VyaXR5X2FkZF9ob29rcyhzdHJ1 Y3Qgc2VjdXJpdHlfaG9va19saXN0ICpob29rcywgaW50IGNvdW50LAotCQkJCWNoYXIgKmxzbSk7 CisJCQkgICAgICAgc3RydWN0IGxzbV9pZCAqbHNtaWQpOwogCiAjZGVmaW5lIExTTV9GTEFHX0xF R0FDWV9NQUpPUglCSVQoMCkKICNkZWZpbmUgTFNNX0ZMQUdfRVhDTFVTSVZFCUJJVCgxKQpkaWZm IC0tZ2l0IGEvaW5jbHVkZS9saW51eC9zZWN1cml0eS5oIGIvaW5jbHVkZS9saW51eC9zZWN1cml0 eS5oCmluZGV4IDA2ZjdjNTBjZTc3Zi4uNjI1ODhiYzUyMmJhIDEwMDY0NAotLS0gYS9pbmNsdWRl L2xpbnV4L3NlY3VyaXR5LmgKKysrIGIvaW5jbHVkZS9saW51eC9zZWN1cml0eS5oCkBAIC0xMzMs NiArMTMzLDY1IEBAIGVudW0gbG9ja2Rvd25fcmVhc29uIHsKIAogZXh0ZXJuIGNvbnN0IGNoYXIg KmNvbnN0IGxvY2tkb3duX3JlYXNvbnNbTE9DS0RPV05fQ09ORklERU5USUFMSVRZX01BWCsxXTsK IAorLyoKKyAqIERhdGEgZXhwb3J0ZWQgYnkgdGhlIHNlY3VyaXR5IG1vZHVsZXMKKyAqCisgKiBB bnkgTFNNIHRoYXQgcHJvdmlkZXMgc2VjaWQgb3Igc2VjY3R4IGJhc2VkIGhvb2tzIG11c3QgYmUg aW5jbHVkZWQuCisgKi8KKyNkZWZpbmUgTFNNQkxPQl9FTlRSSUVTICggXAorCShJU19FTkFCTEVE KENPTkZJR19TRUNVUklUWV9TRUxJTlVYKSA/IDEgOiAwKSArIFwKKwkoSVNfRU5BQkxFRChDT05G SUdfU0VDVVJJVFlfU01BQ0spID8gMSA6IDApICsgXAorCShJU19FTkFCTEVEKENPTkZJR19TRUNV UklUWV9BUFBBUk1PUikgPyAxIDogMCkgKyBcCisJKElTX0VOQUJMRUQoQ09ORklHX0JQRl9MU00p ID8gMSA6IDApKQorCitzdHJ1Y3QgbHNtYmxvYiB7CisJdTMyICAgICBzZWNpZFtMU01CTE9CX0VO VFJJRVNdOworfTsKKworI2RlZmluZSBMU01CTE9CX0lOVkFMSUQJCS0xCS8qIE5vdCBhIHZhbGlk IExTTSBzbG90IG51bWJlciAqLworI2RlZmluZSBMU01CTE9CX05FRURFRAkJLTIJLyogU2xvdCBy ZXF1ZXN0ZWQgb24gaW5pdGlhbGl6YXRpb24gKi8KKyNkZWZpbmUgTFNNQkxPQl9OT1RfTkVFREVE CS0zCS8qIFNsb3Qgbm90IHJlcXVlc3RlZCAqLworCisvKioKKyAqIGxzbWJsb2JfaW5pdCAtIGlu aXRpYWxpemUgYW4gbHNtYmxvYiBzdHJ1Y3R1cmUKKyAqIEBibG9iOiBQb2ludGVyIHRvIHRoZSBk YXRhIHRvIGluaXRpYWxpemUKKyAqIEBzZWNpZDogVGhlIGluaXRpYWwgc2VjaWQgdmFsdWUKKyAq CisgKiBTZXQgYWxsIHNlY2lkIGZvciBhbGwgbW9kdWxlcyB0byB0aGUgc3BlY2lmaWVkIHZhbHVl LgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgbHNtYmxvYl9pbml0KHN0cnVjdCBsc21ibG9iICpi bG9iLCB1MzIgc2VjaWQpCit7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgTFNNQkxPQl9F TlRSSUVTOyBpKyspCisJCWJsb2ItPnNlY2lkW2ldID0gc2VjaWQ7Cit9CisKKy8qKgorICogbHNt YmxvYl9pc19zZXQgLSByZXBvcnQgaWYgdGhlcmUgaXMgYW4gdmFsdWUgaW4gdGhlIGxzbWJsb2IK KyAqIEBibG9iOiBQb2ludGVyIHRvIHRoZSBleHBvcnRlZCBMU00gZGF0YQorICoKKyAqIFJldHVy bnMgdHJ1ZSBpZiB0aGVyZSBpcyBhIHNlY2lkIHNldCwgZmFsc2Ugb3RoZXJ3aXNlCisgKi8KK3N0 YXRpYyBpbmxpbmUgYm9vbCBsc21ibG9iX2lzX3NldChzdHJ1Y3QgbHNtYmxvYiAqYmxvYikKK3sK KwlzdHJ1Y3QgbHNtYmxvYiBlbXB0eSA9IHt9OworCisJcmV0dXJuICEhbWVtY21wKGJsb2IsICZl bXB0eSwgc2l6ZW9mKCpibG9iKSk7Cit9CisKKy8qKgorICogbHNtYmxvYl9lcXVhbCAtIHJlcG9y dCBpZiB0aGUgdHdvIGxzbWJsb2IncyBhcmUgZXF1YWwKKyAqIEBibG9iYTogUG9pbnRlciB0byBv bmUgTFNNIGRhdGEKKyAqIEBibG9iYjogUG9pbnRlciB0byB0aGUgb3RoZXIgTFNNIGRhdGEKKyAq CisgKiBSZXR1cm5zIHRydWUgaWYgYWxsIGVudHJpZXMgaW4gdGhlIHR3byBhcmUgZXF1YWwsIGZh bHNlIG90aGVyd2lzZQorICovCitzdGF0aWMgaW5saW5lIGJvb2wgbHNtYmxvYl9lcXVhbChzdHJ1 Y3QgbHNtYmxvYiAqYmxvYmEsIHN0cnVjdCBsc21ibG9iICpibG9iYikKK3sKKwlyZXR1cm4gIW1l bWNtcChibG9iYSwgYmxvYmIsIHNpemVvZigqYmxvYmEpKTsKK30KKwogLyogVGhlc2UgZnVuY3Rp b25zIGFyZSBpbiBzZWN1cml0eS9jb21tb25jYXAuYyAqLwogZXh0ZXJuIGludCBjYXBfY2FwYWJs ZShjb25zdCBzdHJ1Y3QgY3JlZCAqY3JlZCwgc3RydWN0IHVzZXJfbmFtZXNwYWNlICpucywKIAkJ ICAgICAgIGludCBjYXAsIHVuc2lnbmVkIGludCBvcHRzKTsKQEAgLTE4ODEsOCArMTk0MCw4IEBA IHN0YXRpYyBpbmxpbmUgaW50IHNlY3VyaXR5X2tleV9nZXRzZWN1cml0eShzdHJ1Y3Qga2V5ICpr ZXksIGNoYXIgKipfYnVmZmVyKQogI2lmZGVmIENPTkZJR19TRUNVUklUWQogaW50IHNlY3VyaXR5 X2F1ZGl0X3J1bGVfaW5pdCh1MzIgZmllbGQsIHUzMiBvcCwgY2hhciAqcnVsZXN0ciwgdm9pZCAq KmxzbXJ1bGUpOwogaW50IHNlY3VyaXR5X2F1ZGl0X3J1bGVfa25vd24oc3RydWN0IGF1ZGl0X2ty dWxlICprcnVsZSk7Ci1pbnQgc2VjdXJpdHlfYXVkaXRfcnVsZV9tYXRjaCh1MzIgc2VjaWQsIHUz MiBmaWVsZCwgdTMyIG9wLCB2b2lkICpsc21ydWxlKTsKLXZvaWQgc2VjdXJpdHlfYXVkaXRfcnVs ZV9mcmVlKHZvaWQgKmxzbXJ1bGUpOworaW50IHNlY3VyaXR5X2F1ZGl0X3J1bGVfbWF0Y2godTMy IHNlY2lkLCB1MzIgZmllbGQsIHUzMiBvcCwgdm9pZCAqKmxzbXJ1bGUpOwordm9pZCBzZWN1cml0 eV9hdWRpdF9ydWxlX2ZyZWUodm9pZCAqKmxzbXJ1bGUpOwogCiAjZWxzZQogCkBAIC0xODk4LDEy ICsxOTU3LDEyIEBAIHN0YXRpYyBpbmxpbmUgaW50IHNlY3VyaXR5X2F1ZGl0X3J1bGVfa25vd24o c3RydWN0IGF1ZGl0X2tydWxlICprcnVsZSkKIH0KIAogc3RhdGljIGlubGluZSBpbnQgc2VjdXJp dHlfYXVkaXRfcnVsZV9tYXRjaCh1MzIgc2VjaWQsIHUzMiBmaWVsZCwgdTMyIG9wLAotCQkJCQkg ICAgdm9pZCAqbHNtcnVsZSkKKwkJCQkJICAgIHZvaWQgKipsc21ydWxlKQogewogCXJldHVybiAw OwogfQogCi1zdGF0aWMgaW5saW5lIHZvaWQgc2VjdXJpdHlfYXVkaXRfcnVsZV9mcmVlKHZvaWQg KmxzbXJ1bGUpCitzdGF0aWMgaW5saW5lIHZvaWQgc2VjdXJpdHlfYXVkaXRfcnVsZV9mcmVlKHZv aWQgKipsc21ydWxlKQogeyB9CiAKICNlbmRpZiAvKiBDT05GSUdfU0VDVVJJVFkgKi8KZGlmZiAt LWdpdCBhL2tlcm5lbC9hdWRpdGZpbHRlci5jIGIva2VybmVsL2F1ZGl0ZmlsdGVyLmMKaW5kZXgg ZGIyYzZiNTlkZmMzLi5hMjM0MGU4MWNmYTcgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9hdWRpdGZpbHRl ci5jCisrKyBiL2tlcm5lbC9hdWRpdGZpbHRlci5jCkBAIC03NCw3ICs3NCw3IEBAIHN0YXRpYyB2 b2lkIGF1ZGl0X2ZyZWVfbHNtX2ZpZWxkKHN0cnVjdCBhdWRpdF9maWVsZCAqZikKIAljYXNlIEFV RElUX09CSl9MRVZfTE9XOgogCWNhc2UgQVVESVRfT0JKX0xFVl9ISUdIOgogCQlrZnJlZShmLT5s c21fc3RyKTsKLQkJc2VjdXJpdHlfYXVkaXRfcnVsZV9mcmVlKGYtPmxzbV9ydWxlKTsKKwkJc2Vj dXJpdHlfYXVkaXRfcnVsZV9mcmVlKGYtPmxzbV9ydWxlcyk7CiAJfQogfQogCkBAIC01MTksOSAr NTE5LDEwIEBAIHN0YXRpYyBzdHJ1Y3QgYXVkaXRfZW50cnkgKmF1ZGl0X2RhdGFfdG9fZW50cnko c3RydWN0IGF1ZGl0X3J1bGVfZGF0YSAqZGF0YSwKIAkJCQlnb3RvIGV4aXRfZnJlZTsKIAkJCX0K IAkJCWVudHJ5LT5ydWxlLmJ1ZmxlbiArPSBmX3ZhbDsKKwkJCWYtPmxzbV9pc3NldCA9IHRydWU7 CiAJCQlmLT5sc21fc3RyID0gc3RyOwogCQkJZXJyID0gc2VjdXJpdHlfYXVkaXRfcnVsZV9pbml0 KGYtPnR5cGUsIGYtPm9wLCBzdHIsCi0JCQkJCQkgICAgICAgKHZvaWQgKiopJmYtPmxzbV9ydWxl KTsKKwkJCQkJCSAgICAgICBmLT5sc21fcnVsZXMpOwogCQkJLyogS2VlcCBjdXJyZW50bHkgaW52 YWxpZCBmaWVsZHMgYXJvdW5kIGluIGNhc2UgdGhleQogCQkJICogYmVjb21lIHZhbGlkIGFmdGVy IGEgcG9saWN5IHJlbG9hZC4gKi8KIAkJCWlmIChlcnIgPT0gLUVJTlZBTCkgewpAQCAtNzc0LDcg Kzc3NSw3IEBAIHN0YXRpYyBpbnQgYXVkaXRfY29tcGFyZV9ydWxlKHN0cnVjdCBhdWRpdF9rcnVs ZSAqYSwgc3RydWN0IGF1ZGl0X2tydWxlICpiKQogCXJldHVybiAwOwogfQogCi0vKiBEdXBsaWNh dGUgTFNNIGZpZWxkIGluZm9ybWF0aW9uLiAgVGhlIGxzbV9ydWxlIGlzIG9wYXF1ZSwgc28gbXVz dCBiZQorLyogRHVwbGljYXRlIExTTSBmaWVsZCBpbmZvcm1hdGlvbi4gIFRoZSBsc21fcnVsZXMg aXMgb3BhcXVlLCBzbyBtdXN0IGJlCiAgKiByZS1pbml0aWFsaXplZC4gKi8KIHN0YXRpYyBpbmxp bmUgaW50IGF1ZGl0X2R1cGVfbHNtX2ZpZWxkKHN0cnVjdCBhdWRpdF9maWVsZCAqZGYsCiAJCQkJ CSAgIHN0cnVjdCBhdWRpdF9maWVsZCAqc2YpCkBAIC03ODgsOSArNzg5LDkgQEAgc3RhdGljIGlu bGluZSBpbnQgYXVkaXRfZHVwZV9sc21fZmllbGQoc3RydWN0IGF1ZGl0X2ZpZWxkICpkZiwKIAkJ cmV0dXJuIC1FTk9NRU07CiAJZGYtPmxzbV9zdHIgPSBsc21fc3RyOwogCi0JLyogb3VyIG93biAo cmVmcmVzaGVkKSBjb3B5IG9mIGxzbV9ydWxlICovCisJLyogb3VyIG93biAocmVmcmVzaGVkKSBj b3B5IG9mIGxzbV9ydWxlcyAqLwogCXJldCA9IHNlY3VyaXR5X2F1ZGl0X3J1bGVfaW5pdChkZi0+ dHlwZSwgZGYtPm9wLCBkZi0+bHNtX3N0ciwKLQkJCQkgICAgICAgKHZvaWQgKiopJmRmLT5sc21f cnVsZSk7CisJCQkJICAgICAgIGRmLT5sc21fcnVsZXMpOwogCS8qIEtlZXAgY3VycmVudGx5IGlu dmFsaWQgZmllbGRzIGFyb3VuZCBpbiBjYXNlIHRoZXkKIAkgKiBiZWNvbWUgdmFsaWQgYWZ0ZXIg YSBwb2xpY3kgcmVsb2FkLiAqLwogCWlmIChyZXQgPT0gLUVJTlZBTCkgewpAQCAtODQyLDcgKzg0 Myw3IEBAIHN0cnVjdCBhdWRpdF9lbnRyeSAqYXVkaXRfZHVwZV9ydWxlKHN0cnVjdCBhdWRpdF9r cnVsZSAqb2xkKQogCW5ldy0+dHJlZSA9IG9sZC0+dHJlZTsKIAltZW1jcHkobmV3LT5maWVsZHMs IG9sZC0+ZmllbGRzLCBzaXplb2Yoc3RydWN0IGF1ZGl0X2ZpZWxkKSAqIGZjb3VudCk7CiAKLQkv KiBkZWVwIGNvcHkgdGhpcyBpbmZvcm1hdGlvbiwgdXBkYXRpbmcgdGhlIGxzbV9ydWxlIGZpZWxk cywgYmVjYXVzZQorCS8qIGRlZXAgY29weSB0aGlzIGluZm9ybWF0aW9uLCB1cGRhdGluZyB0aGUg bHNtX3J1bGVzIGZpZWxkcywgYmVjYXVzZQogCSAqIHRoZSBvcmlnaW5hbHMgd2lsbCBhbGwgYmUg ZnJlZWQgd2hlbiB0aGUgb2xkIHJ1bGUgaXMgZnJlZWQuICovCiAJZm9yIChpID0gMDsgaSA8IGZj b3VudDsgaSsrKSB7CiAJCXN3aXRjaCAobmV3LT5maWVsZHNbaV0udHlwZSkgewpAQCAtMTM1OCwx MSArMTM1OSwxMiBAQCBpbnQgYXVkaXRfZmlsdGVyKGludCBtc2d0eXBlLCB1bnNpZ25lZCBpbnQg bGlzdHR5cGUpCiAJCQljYXNlIEFVRElUX1NVQkpfVFlQRToKIAkJCWNhc2UgQVVESVRfU1VCSl9T RU46CiAJCQljYXNlIEFVRElUX1NVQkpfQ0xSOgotCQkJCWlmIChmLT5sc21fcnVsZSkgeworCQkJ CWlmIChmLT5sc21faXNzZXQpIHsKIAkJCQkJc2VjdXJpdHlfdGFza19nZXRzZWNpZF9zdWJqKGN1 cnJlbnQsCiAJCQkJCQkJCSAgICAmc2lkKTsKIAkJCQkJcmVzdWx0ID0gc2VjdXJpdHlfYXVkaXRf cnVsZV9tYXRjaChzaWQsCi0JCQkJCQkgICBmLT50eXBlLCBmLT5vcCwgZi0+bHNtX3J1bGUpOwor CQkJCQkJICAgZi0+dHlwZSwgZi0+b3AsCisJCQkJCQkgICBmLT5sc21fcnVsZXMpOwogCQkJCX0K IAkJCQlicmVhazsKIAkJCWNhc2UgQVVESVRfRVhFOgpAQCAtMTM4OSw3ICsxMzkxLDcgQEAgaW50 IGF1ZGl0X2ZpbHRlcihpbnQgbXNndHlwZSwgdW5zaWduZWQgaW50IGxpc3R0eXBlKQogCXJldHVy biByZXQ7CiB9CiAKLXN0YXRpYyBpbnQgdXBkYXRlX2xzbV9ydWxlKHN0cnVjdCBhdWRpdF9rcnVs ZSAqcikKK3N0YXRpYyBpbnQgdXBkYXRlX2xzbV9ydWxlcyhzdHJ1Y3QgYXVkaXRfa3J1bGUgKnIp CiB7CiAJc3RydWN0IGF1ZGl0X2VudHJ5ICplbnRyeSA9IGNvbnRhaW5lcl9vZihyLCBzdHJ1Y3Qg YXVkaXRfZW50cnksIHJ1bGUpOwogCXN0cnVjdCBhdWRpdF9lbnRyeSAqbmVudHJ5OwpAQCAtMTQy MSw3ICsxNDIzLDcgQEAgc3RhdGljIGludCB1cGRhdGVfbHNtX3J1bGUoc3RydWN0IGF1ZGl0X2ty dWxlICpyKQogCXJldHVybiBlcnI7CiB9CiAKLS8qIFRoaXMgZnVuY3Rpb24gd2lsbCByZS1pbml0 aWFsaXplIHRoZSBsc21fcnVsZSBmaWVsZCBvZiBhbGwgYXBwbGljYWJsZSBydWxlcy4KKy8qIFRo aXMgZnVuY3Rpb24gd2lsbCByZS1pbml0aWFsaXplIHRoZSBsc21fcnVsZXMgZmllbGQgb2YgYWxs IGFwcGxpY2FibGUgcnVsZXMuCiAgKiBJdCB3aWxsIHRyYXZlcnNlIHRoZSBmaWx0ZXIgbGlzdHMg c2VyYXJjaGluZyBmb3IgcnVsZXMgdGhhdCBjb250YWluIExTTQogICogc3BlY2lmaWMgZmlsdGVy IGZpZWxkcy4gIFdoZW4gc3VjaCBhIHJ1bGUgaXMgZm91bmQsIGl0IGlzIGNvcGllZCwgdGhlCiAg KiBMU00gZmllbGQgaXMgcmUtaW5pdGlhbGl6ZWQsIGFuZCB0aGUgb2xkIHJ1bGUgaXMgcmVwbGFj ZWQgd2l0aCB0aGUKQEAgLTE0MzYsNyArMTQzOCw3IEBAIGludCBhdWRpdF91cGRhdGVfbHNtX3J1 bGVzKHZvaWQpCiAKIAlmb3IgKGkgPSAwOyBpIDwgQVVESVRfTlJfRklMVEVSUzsgaSsrKSB7CiAJ CWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShyLCBuLCAmYXVkaXRfcnVsZXNfbGlzdFtpXSwgbGlz dCkgewotCQkJaW50IHJlcyA9IHVwZGF0ZV9sc21fcnVsZShyKTsKKwkJCWludCByZXMgPSB1cGRh dGVfbHNtX3J1bGVzKHIpOwogCQkJaWYgKCFlcnIpCiAJCQkJZXJyID0gcmVzOwogCQl9CmRpZmYg LS1naXQgYS9rZXJuZWwvYXVkaXRzYy5jIGIva2VybmVsL2F1ZGl0c2MuYwppbmRleCAxNzVlZjZm M2VhNGUuLjM5MmFmZTNlMmZkNiAxMDA2NDQKLS0tIGEva2VybmVsL2F1ZGl0c2MuYworKysgYi9r ZXJuZWwvYXVkaXRzYy5jCkBAIC02NjUsMTQgKzY2NSwxMyBAQCBzdGF0aWMgaW50IGF1ZGl0X2Zp bHRlcl9ydWxlcyhzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzaywKIAkJCSAgIG1hdGNoIGZvciBub3cg dG8gYXZvaWQgbG9zaW5nIGluZm9ybWF0aW9uIHRoYXQKIAkJCSAgIG1heSBiZSB3YW50ZWQuICAg QW4gZXJyb3IgbWVzc2FnZSB3aWxsIGFsc28gYmUKIAkJCSAgIGxvZ2dlZCB1cG9uIGVycm9yICov Ci0JCQlpZiAoZi0+bHNtX3J1bGUpIHsKKwkJCWlmIChmLT5sc21faXNzZXQpIHsKIAkJCQlpZiAo bmVlZF9zaWQpIHsKIAkJCQkJc2VjdXJpdHlfdGFza19nZXRzZWNpZF9zdWJqKHRzaywgJnNpZCk7 CiAJCQkJCW5lZWRfc2lkID0gMDsKIAkJCQl9CiAJCQkJcmVzdWx0ID0gc2VjdXJpdHlfYXVkaXRf cnVsZV9tYXRjaChzaWQsIGYtPnR5cGUsCi0JCQkJCQkJCSAgIGYtPm9wLAotCQkJCQkJCQkgICBm LT5sc21fcnVsZSk7CisJCQkJCQkJZi0+b3AsIGYtPmxzbV9ydWxlcyk7CiAJCQl9CiAJCQlicmVh azsKIAkJY2FzZSBBVURJVF9PQkpfVVNFUjoKQEAgLTY4MiwyMSArNjgxLDIxIEBAIHN0YXRpYyBp bnQgYXVkaXRfZmlsdGVyX3J1bGVzKHN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrLAogCQljYXNlIEFV RElUX09CSl9MRVZfSElHSDoKIAkJCS8qIFRoZSBhYm92ZSBub3RlIGZvciBBVURJVF9TVUJKX1VT RVIuLi5BVURJVF9TVUJKX0NMUgogCQkJICAgYWxzbyBhcHBsaWVzIGhlcmUgKi8KLQkJCWlmIChm LT5sc21fcnVsZSkgeworCQkJaWYgKGYtPmxzbV9pc3NldCkgewogCQkJCS8qIEZpbmQgZmlsZXMg dGhhdCBtYXRjaCAqLwogCQkJCWlmIChuYW1lKSB7CiAJCQkJCXJlc3VsdCA9IHNlY3VyaXR5X2F1 ZGl0X3J1bGVfbWF0Y2goCiAJCQkJCQkJCW5hbWUtPm9zaWQsCiAJCQkJCQkJCWYtPnR5cGUsCiAJ CQkJCQkJCWYtPm9wLAotCQkJCQkJCQlmLT5sc21fcnVsZSk7CisJCQkJCQkJCWYtPmxzbV9ydWxl cyk7CiAJCQkJfSBlbHNlIGlmIChjdHgpIHsKIAkJCQkJbGlzdF9mb3JfZWFjaF9lbnRyeShuLCAm Y3R4LT5uYW1lc19saXN0LCBsaXN0KSB7CiAJCQkJCQlpZiAoc2VjdXJpdHlfYXVkaXRfcnVsZV9t YXRjaCgKIAkJCQkJCQkJbi0+b3NpZCwKIAkJCQkJCQkJZi0+dHlwZSwKIAkJCQkJCQkJZi0+b3As Ci0JCQkJCQkJCWYtPmxzbV9ydWxlKSkgeworCQkJCQkJCQlmLT5sc21fcnVsZXMpKSB7CiAJCQkJ CQkJKytyZXN1bHQ7CiAJCQkJCQkJYnJlYWs7CiAJCQkJCQl9CkBAIC03MDcsNyArNzA2LDcgQEAg c3RhdGljIGludCBhdWRpdF9maWx0ZXJfcnVsZXMoc3RydWN0IHRhc2tfc3RydWN0ICp0c2ssCiAJ CQkJCWJyZWFrOwogCQkJCWlmIChzZWN1cml0eV9hdWRpdF9ydWxlX21hdGNoKGN0eC0+aXBjLm9z aWQsCiAJCQkJCQkJICAgICAgZi0+dHlwZSwgZi0+b3AsCi0JCQkJCQkJICAgICAgZi0+bHNtX3J1 bGUpKQorCQkJCQkJCSAgICAgIGYtPmxzbV9ydWxlcykpCiAJCQkJCSsrcmVzdWx0OwogCQkJfQog CQkJYnJlYWs7CmRpZmYgLS1naXQgYS9zZWN1cml0eS9hcHBhcm1vci9sc20uYyBiL3NlY3VyaXR5 L2FwcGFybW9yL2xzbS5jCmluZGV4IDQxMTM1MTZmYjYyZS4uMzkyZTI1OTQwZDFmIDEwMDY0NAot LS0gYS9zZWN1cml0eS9hcHBhcm1vci9sc20uYworKysgYi9zZWN1cml0eS9hcHBhcm1vci9sc20u YwpAQCAtMTE2MSw2ICsxMTYxLDExIEBAIHN0cnVjdCBsc21fYmxvYl9zaXplcyBhcHBhcm1vcl9i bG9iX3NpemVzIF9fbHNtX3JvX2FmdGVyX2luaXQgPSB7CiAJLmxic19zb2NrID0gc2l6ZW9mKHN0 cnVjdCBhYV9za19jdHgpLAogfTsKIAorc3RhdGljIHN0cnVjdCBsc21faWQgYXBwYXJtb3JfbHNt aWQgX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKKwkubHNtICA9ICJhcHBhcm1vciIsCisJLnNsb3Qg PSBMU01CTE9CX05FRURFRAorfTsKKwogc3RhdGljIHN0cnVjdCBzZWN1cml0eV9ob29rX2xpc3Qg YXBwYXJtb3JfaG9va3NbXSBfX2xzbV9yb19hZnRlcl9pbml0ID0gewogCUxTTV9IT09LX0lOSVQo cHRyYWNlX2FjY2Vzc19jaGVjaywgYXBwYXJtb3JfcHRyYWNlX2FjY2Vzc19jaGVjayksCiAJTFNN X0hPT0tfSU5JVChwdHJhY2VfdHJhY2VtZSwgYXBwYXJtb3JfcHRyYWNlX3RyYWNlbWUpLApAQCAt MTg2Miw3ICsxODY3LDcgQEAgc3RhdGljIGludCBfX2luaXQgYXBwYXJtb3JfaW5pdCh2b2lkKQog CQlnb3RvIGJ1ZmZlcnNfb3V0OwogCX0KIAlzZWN1cml0eV9hZGRfaG9va3MoYXBwYXJtb3JfaG9v a3MsIEFSUkFZX1NJWkUoYXBwYXJtb3JfaG9va3MpLAotCQkJCSJhcHBhcm1vciIpOworCQkJCSZh cHBhcm1vcl9sc21pZCk7CiAKIAkvKiBSZXBvcnQgdGhhdCBBcHBBcm1vciBzdWNjZXNzZnVsbHkg aW5pdGlhbGl6ZWQgKi8KIAlhcHBhcm1vcl9pbml0aWFsaXplZCA9IDE7CmRpZmYgLS1naXQgYS9z ZWN1cml0eS9icGYvaG9va3MuYyBiL3NlY3VyaXR5L2JwZi9ob29rcy5jCmluZGV4IGU1OTcxZmE3 NGZkNy4uN2E1OGZlOWFiOGM0IDEwMDY0NAotLS0gYS9zZWN1cml0eS9icGYvaG9va3MuYworKysg Yi9zZWN1cml0eS9icGYvaG9va3MuYwpAQCAtMTUsOSArMTUsMTkgQEAgc3RhdGljIHN0cnVjdCBz ZWN1cml0eV9ob29rX2xpc3QgYnBmX2xzbV9ob29rc1tdIF9fbHNtX3JvX2FmdGVyX2luaXQgPSB7 CiAJTFNNX0hPT0tfSU5JVCh0YXNrX2ZyZWUsIGJwZl90YXNrX3N0b3JhZ2VfZnJlZSksCiB9Owog CisvKgorICogc2xvdCBoYXMgdG8gYmUgTFNNQkxPQl9ORUVERUQgYmVjYXVzZSBzb21lIG9mIHRo ZSBob29rcworICogc3VwcGxpZWQgYnkgdGhpcyBtb2R1bGUgcmVxdWlyZSBhIHNsb3QuCisgKi8K K3N0cnVjdCBsc21faWQgYnBmX2xzbWlkIF9fbHNtX3JvX2FmdGVyX2luaXQgPSB7CisJLmxzbSA9 ICJicGYiLAorCS5zbG90ID0gTFNNQkxPQl9ORUVERUQKK307CisKIHN0YXRpYyBpbnQgX19pbml0 IGJwZl9sc21faW5pdCh2b2lkKQogewotCXNlY3VyaXR5X2FkZF9ob29rcyhicGZfbHNtX2hvb2tz LCBBUlJBWV9TSVpFKGJwZl9sc21faG9va3MpLCAiYnBmIik7CisJc2VjdXJpdHlfYWRkX2hvb2tz KGJwZl9sc21faG9va3MsIEFSUkFZX1NJWkUoYnBmX2xzbV9ob29rcyksCisJCQkgICAmYnBmX2xz bWlkKTsKIAlwcl9pbmZvKCJMU00gc3VwcG9ydCBmb3IgZUJQRiBhY3RpdmVcbiIpOwogCXJldHVy biAwOwogfQpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkvY29tbW9uY2FwLmMgYi9zZWN1cml0eS9jb21t b25jYXAuYwppbmRleCAzZjgxMGQzN2I3MWIuLjYyODY4NWNmMjBlMyAxMDA2NDQKLS0tIGEvc2Vj dXJpdHkvY29tbW9uY2FwLmMKKysrIGIvc2VjdXJpdHkvY29tbW9uY2FwLmMKQEAgLTE0NDMsNiAr MTQ0MywxMSBAQCBpbnQgY2FwX21tYXBfZmlsZShzdHJ1Y3QgZmlsZSAqZmlsZSwgdW5zaWduZWQg bG9uZyByZXFwcm90LAogCiAjaWZkZWYgQ09ORklHX1NFQ1VSSVRZCiAKK3N0YXRpYyBzdHJ1Y3Qg bHNtX2lkIGNhcGFiaWxpdHlfbHNtaWQgX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKKwkubHNtICA9 ICJjYXBhYmlsaXR5IiwKKwkuc2xvdCA9IExTTUJMT0JfTk9UX05FRURFRAorfTsKKwogc3RhdGlj IHN0cnVjdCBzZWN1cml0eV9ob29rX2xpc3QgY2FwYWJpbGl0eV9ob29rc1tdIF9fbHNtX3JvX2Fm dGVyX2luaXQgPSB7CiAJTFNNX0hPT0tfSU5JVChjYXBhYmxlLCBjYXBfY2FwYWJsZSksCiAJTFNN X0hPT0tfSU5JVChzZXR0aW1lLCBjYXBfc2V0dGltZSksCkBAIC0xNDY3LDcgKzE0NzIsNyBAQCBz dGF0aWMgc3RydWN0IHNlY3VyaXR5X2hvb2tfbGlzdCBjYXBhYmlsaXR5X2hvb2tzW10gX19sc21f cm9fYWZ0ZXJfaW5pdCA9IHsKIHN0YXRpYyBpbnQgX19pbml0IGNhcGFiaWxpdHlfaW5pdCh2b2lk KQogewogCXNlY3VyaXR5X2FkZF9ob29rcyhjYXBhYmlsaXR5X2hvb2tzLCBBUlJBWV9TSVpFKGNh cGFiaWxpdHlfaG9va3MpLAotCQkJCSJjYXBhYmlsaXR5Iik7CisJCQkgICAmY2FwYWJpbGl0eV9s c21pZCk7CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL3NlY3VyaXR5L2ludGVncml0eS9p bWEvaW1hX3BvbGljeS5jIGIvc2VjdXJpdHkvaW50ZWdyaXR5L2ltYS9pbWFfcG9saWN5LmMKaW5k ZXggZmQ1ZDQ2ZTUxMWYxLi41YzQwNjc3ZTg4MWMgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L2ludGVn cml0eS9pbWEvaW1hX3BvbGljeS5jCisrKyBiL3NlY3VyaXR5L2ludGVncml0eS9pbWEvaW1hX3Bv bGljeS5jCkBAIC04MCw3ICs4MCw3IEBAIHN0cnVjdCBpbWFfcnVsZV9lbnRyeSB7CiAJYm9vbCAo KmZvd25lcl9vcCkoa3VpZF90LCBrdWlkX3QpOyAvKiB1aWRfZXEoKSwgdWlkX2d0KCksIHVpZF9s dCgpICovCiAJaW50IHBjcjsKIAlzdHJ1Y3QgewotCQl2b2lkICpydWxlOwkvKiBMU00gZmlsZSBt ZXRhZGF0YSBzcGVjaWZpYyAqLworCQl2b2lkICpydWxlc1tMU01CTE9CX0VOVFJJRVNdOyAvKiBM U00gZmlsZSBtZXRhZGF0YSBzcGVjaWZpYyAqLwogCQljaGFyICphcmdzX3A7CS8qIGF1ZGl0IHZh bHVlICovCiAJCWludCB0eXBlOwkvKiBhdWRpdCB0eXBlICovCiAJfSBsc21bTUFYX0xTTV9SVUxF U107CkBAIC05MCw2ICs5MCwyMiBAQCBzdHJ1Y3QgaW1hX3J1bGVfZW50cnkgewogCXN0cnVjdCBp bWFfdGVtcGxhdGVfZGVzYyAqdGVtcGxhdGU7CiB9OwogCisvKioKKyAqIGltYV9sc21faXNzZXQg LSBJcyBhIHJ1bGUgc2V0IGZvciBhbnkgb2YgdGhlIGFjdGl2ZSBzZWN1cml0eSBtb2R1bGVzCisg KiBAcnVsZXM6IFRoZSBzZXQgb2YgSU1BIHJ1bGVzIHRvIGNoZWNrCisgKgorICogSWYgYSBydWxl IGlzIHNldCBmb3IgYW55IExTTSByZXR1cm4gdHJ1ZSwgb3RoZXJ3aXNlIHJldHVybiBmYWxzZS4K KyAqLworc3RhdGljIGlubGluZSBib29sIGltYV9sc21faXNzZXQodm9pZCAqcnVsZXNbXSkKK3sK KwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBMU01CTE9CX0VOVFJJRVM7IGkrKykKKwkJaWYg KHJ1bGVzW2ldKQorCQkJcmV0dXJuIHRydWU7CisJcmV0dXJuIGZhbHNlOworfQorCiAvKgogICog V2l0aG91dCBMU00gc3BlY2lmaWMga25vd2xlZGdlLCB0aGUgZGVmYXVsdCBwb2xpY3kgY2FuIG9u bHkgYmUKICAqIHdyaXR0ZW4gaW4gdGVybXMgb2YgLmFjdGlvbiwgLmZ1bmMsIC5tYXNrLCAuZnNt YWdpYywgLnVpZCwgYW5kIC5mb3duZXIKQEAgLTMzNSw5ICszNTEsMTEgQEAgc3RhdGljIHZvaWQg aW1hX2ZyZWVfcnVsZV9vcHRfbGlzdChzdHJ1Y3QgaW1hX3J1bGVfb3B0X2xpc3QgKm9wdF9saXN0 KQogc3RhdGljIHZvaWQgaW1hX2xzbV9mcmVlX3J1bGUoc3RydWN0IGltYV9ydWxlX2VudHJ5ICpl bnRyeSkKIHsKIAlpbnQgaTsKKwlpbnQgcjsKIAogCWZvciAoaSA9IDA7IGkgPCBNQVhfTFNNX1JV TEVTOyBpKyspIHsKLQkJaW1hX2ZpbHRlcl9ydWxlX2ZyZWUoZW50cnktPmxzbVtpXS5ydWxlKTsK KwkJZm9yIChyID0gMDsgciA8IExTTUJMT0JfRU5UUklFUzsgcisrKQorCQkJaW1hX2ZpbHRlcl9y dWxlX2ZyZWUoZW50cnktPmxzbVtpXS5ydWxlc1tyXSk7CiAJCWtmcmVlKGVudHJ5LT5sc21baV0u YXJnc19wKTsKIAl9CiB9CkBAIC0zODgsOCArNDA2LDggQEAgc3RhdGljIHN0cnVjdCBpbWFfcnVs ZV9lbnRyeSAqaW1hX2xzbV9jb3B5X3J1bGUoc3RydWN0IGltYV9ydWxlX2VudHJ5ICplbnRyeSkK IAogCQlpbWFfZmlsdGVyX3J1bGVfaW5pdChuZW50cnktPmxzbVtpXS50eXBlLCBBdWRpdF9lcXVh bCwKIAkJCQkgICAgIG5lbnRyeS0+bHNtW2ldLmFyZ3NfcCwKLQkJCQkgICAgICZuZW50cnktPmxz bVtpXS5ydWxlKTsKLQkJaWYgKCFuZW50cnktPmxzbVtpXS5ydWxlKQorCQkJCSAgICAgJm5lbnRy eS0+bHNtW2ldLnJ1bGVzWzBdKTsKKwkJaWYgKCFpbWFfbHNtX2lzc2V0KG5lbnRyeS0+bHNtW2ld LnJ1bGVzKSkKIAkJCXByX3dhcm4oInJ1bGUgZm9yIExTTSBcJyVzXCcgaXMgdW5kZWZpbmVkXG4i LAogCQkJCW5lbnRyeS0+bHNtW2ldLmFyZ3NfcCk7CiAJfQpAQCAtNTc4LDcgKzU5Niw3IEBAIHN0 YXRpYyBib29sIGltYV9tYXRjaF9ydWxlcyhzdHJ1Y3QgaW1hX3J1bGVfZW50cnkgKnJ1bGUsCiAJ CWludCByYyA9IDA7CiAJCXUzMiBvc2lkOwogCi0JCWlmICghcnVsZS0+bHNtW2ldLnJ1bGUpIHsK KwkJaWYgKCFpbWFfbHNtX2lzc2V0KHJ1bGUtPmxzbVtpXS5ydWxlcykpIHsKIAkJCWlmICghcnVs ZS0+bHNtW2ldLmFyZ3NfcCkKIAkJCQljb250aW51ZTsKIAkJCWVsc2UKQEAgLTU5MSwxNCArNjA5 LDE0IEBAIHN0YXRpYyBib29sIGltYV9tYXRjaF9ydWxlcyhzdHJ1Y3QgaW1hX3J1bGVfZW50cnkg KnJ1bGUsCiAJCQlzZWN1cml0eV9pbm9kZV9nZXRzZWNpZChpbm9kZSwgJm9zaWQpOwogCQkJcmMg PSBpbWFfZmlsdGVyX3J1bGVfbWF0Y2gob3NpZCwgcnVsZS0+bHNtW2ldLnR5cGUsCiAJCQkJCQkg ICBBdWRpdF9lcXVhbCwKLQkJCQkJCSAgIHJ1bGUtPmxzbVtpXS5ydWxlKTsKKwkJCQkJCSAgIHJ1 bGUtPmxzbVtpXS5ydWxlcyk7CiAJCQlicmVhazsKIAkJY2FzZSBMU01fU1VCSl9VU0VSOgogCQlj YXNlIExTTV9TVUJKX1JPTEU6CiAJCWNhc2UgTFNNX1NVQkpfVFlQRToKIAkJCXJjID0gaW1hX2Zp bHRlcl9ydWxlX21hdGNoKHNlY2lkLCBydWxlLT5sc21baV0udHlwZSwKIAkJCQkJCSAgIEF1ZGl0 X2VxdWFsLAotCQkJCQkJICAgcnVsZS0+bHNtW2ldLnJ1bGUpOworCQkJCQkJICAgcnVsZS0+bHNt W2ldLnJ1bGVzKTsKIAkJCWJyZWFrOwogCQlkZWZhdWx0OgogCQkJYnJlYWs7CkBAIC05OTQsNyAr MTAxMiw3IEBAIHN0YXRpYyBpbnQgaW1hX2xzbV9ydWxlX2luaXQoc3RydWN0IGltYV9ydWxlX2Vu dHJ5ICplbnRyeSwKIHsKIAlpbnQgcmVzdWx0OwogCi0JaWYgKGVudHJ5LT5sc21bbHNtX3J1bGVd LnJ1bGUpCisJaWYgKGltYV9sc21faXNzZXQoZW50cnktPmxzbVtsc21fcnVsZV0ucnVsZXMpKQog CQlyZXR1cm4gLUVJTlZBTDsKIAogCWVudHJ5LT5sc21bbHNtX3J1bGVdLmFyZ3NfcCA9IG1hdGNo X3N0cmR1cChhcmdzKTsKQEAgLTEwMDQsOCArMTAyMiw4IEBAIHN0YXRpYyBpbnQgaW1hX2xzbV9y dWxlX2luaXQoc3RydWN0IGltYV9ydWxlX2VudHJ5ICplbnRyeSwKIAllbnRyeS0+bHNtW2xzbV9y dWxlXS50eXBlID0gYXVkaXRfdHlwZTsKIAlyZXN1bHQgPSBpbWFfZmlsdGVyX3J1bGVfaW5pdChl bnRyeS0+bHNtW2xzbV9ydWxlXS50eXBlLCBBdWRpdF9lcXVhbCwKIAkJCQkgICAgICBlbnRyeS0+ bHNtW2xzbV9ydWxlXS5hcmdzX3AsCi0JCQkJICAgICAgJmVudHJ5LT5sc21bbHNtX3J1bGVdLnJ1 bGUpOwotCWlmICghZW50cnktPmxzbVtsc21fcnVsZV0ucnVsZSkgeworCQkJCSAgICAgICZlbnRy eS0+bHNtW2xzbV9ydWxlXS5ydWxlc1swXSk7CisJaWYgKCFpbWFfbHNtX2lzc2V0KGVudHJ5LT5s c21bbHNtX3J1bGVdLnJ1bGVzKSkgewogCQlwcl93YXJuKCJydWxlIGZvciBMU00gXCclc1wnIGlz IHVuZGVmaW5lZFxuIiwKIAkJCWVudHJ5LT5sc21bbHNtX3J1bGVdLmFyZ3NfcCk7CiAKQEAgLTE4 MTIsNyArMTgzMCw3IEBAIGludCBpbWFfcG9saWN5X3Nob3coc3RydWN0IHNlcV9maWxlICptLCB2 b2lkICp2KQogCX0KIAogCWZvciAoaSA9IDA7IGkgPCBNQVhfTFNNX1JVTEVTOyBpKyspIHsKLQkJ aWYgKGVudHJ5LT5sc21baV0ucnVsZSkgeworCQlpZiAoaW1hX2xzbV9pc3NldChlbnRyeS0+bHNt W2ldLnJ1bGVzKSkgewogCQkJc3dpdGNoIChpKSB7CiAJCQljYXNlIExTTV9PQkpfVVNFUjoKIAkJ CQlzZXFfcHJpbnRmKG0sIHB0KE9wdF9vYmpfdXNlciksCmRpZmYgLS1naXQgYS9zZWN1cml0eS9s YW5kbG9jay9jcmVkLmMgYi9zZWN1cml0eS9sYW5kbG9jay9jcmVkLmMKaW5kZXggNjcyNWFmMjRj Njg0Li41NmIxMjFkNjU0MzYgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L2xhbmRsb2NrL2NyZWQuYwor KysgYi9zZWN1cml0eS9sYW5kbG9jay9jcmVkLmMKQEAgLTQyLDUgKzQyLDUgQEAgc3RhdGljIHN0 cnVjdCBzZWN1cml0eV9ob29rX2xpc3QgbGFuZGxvY2tfaG9va3NbXSBfX2xzbV9yb19hZnRlcl9p bml0ID0gewogX19pbml0IHZvaWQgbGFuZGxvY2tfYWRkX2NyZWRfaG9va3Modm9pZCkKIHsKIAlz ZWN1cml0eV9hZGRfaG9va3MobGFuZGxvY2tfaG9va3MsIEFSUkFZX1NJWkUobGFuZGxvY2tfaG9v a3MpLAotCQkJTEFORExPQ0tfTkFNRSk7CisJCQkmbGFuZGxvY2tfbHNtaWQpOwogfQpkaWZmIC0t Z2l0IGEvc2VjdXJpdHkvbGFuZGxvY2svZnMuYyBiL3NlY3VyaXR5L2xhbmRsb2NrL2ZzLmMKaW5k ZXggOTdiOGU0MjFmNjE3Li4zMTllOTBlOTI5MGMgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L2xhbmRs b2NrL2ZzLmMKKysrIGIvc2VjdXJpdHkvbGFuZGxvY2svZnMuYwpAQCAtNjg4LDUgKzY4OCw1IEBA IHN0YXRpYyBzdHJ1Y3Qgc2VjdXJpdHlfaG9va19saXN0IGxhbmRsb2NrX2hvb2tzW10gX19sc21f cm9fYWZ0ZXJfaW5pdCA9IHsKIF9faW5pdCB2b2lkIGxhbmRsb2NrX2FkZF9mc19ob29rcyh2b2lk KQogewogCXNlY3VyaXR5X2FkZF9ob29rcyhsYW5kbG9ja19ob29rcywgQVJSQVlfU0laRShsYW5k bG9ja19ob29rcyksCi0JCQlMQU5ETE9DS19OQU1FKTsKKwkJCSZsYW5kbG9ja19sc21pZCk7CiB9 CmRpZmYgLS1naXQgYS9zZWN1cml0eS9sYW5kbG9jay9wdHJhY2UuYyBiL3NlY3VyaXR5L2xhbmRs b2NrL3B0cmFjZS5jCmluZGV4IGY1NWI4MjQ0NmRlMi4uNTRjY2Y1NWEwNzdhIDEwMDY0NAotLS0g YS9zZWN1cml0eS9sYW5kbG9jay9wdHJhY2UuYworKysgYi9zZWN1cml0eS9sYW5kbG9jay9wdHJh Y2UuYwpAQCAtMTE2LDUgKzExNiw1IEBAIHN0YXRpYyBzdHJ1Y3Qgc2VjdXJpdHlfaG9va19saXN0 IGxhbmRsb2NrX2hvb2tzW10gX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKIF9faW5pdCB2b2lkIGxh bmRsb2NrX2FkZF9wdHJhY2VfaG9va3Modm9pZCkKIHsKIAlzZWN1cml0eV9hZGRfaG9va3MobGFu ZGxvY2tfaG9va3MsIEFSUkFZX1NJWkUobGFuZGxvY2tfaG9va3MpLAotCQkJTEFORExPQ0tfTkFN RSk7CisJCQkmbGFuZGxvY2tfbHNtaWQpOwogfQpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkvbGFuZGxv Y2svc2V0dXAuYyBiL3NlY3VyaXR5L2xhbmRsb2NrL3NldHVwLmMKaW5kZXggZjhlOGU5ODA0NTRj Li40YTEyNjY2YTQwOTAgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L2xhbmRsb2NrL3NldHVwLmMKKysr IGIvc2VjdXJpdHkvbGFuZGxvY2svc2V0dXAuYwpAQCAtMjMsNiArMjMsMTAgQEAgc3RydWN0IGxz bV9ibG9iX3NpemVzIGxhbmRsb2NrX2Jsb2Jfc2l6ZXMgX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsK IAkubGJzX3N1cGVyYmxvY2sgPSBzaXplb2Yoc3RydWN0IGxhbmRsb2NrX3N1cGVyYmxvY2tfc2Vj dXJpdHkpLAogfTsKIAorc3RydWN0IGxzbV9pZCBsYW5kbG9ja19sc21pZCBfX2xzbV9yb19hZnRl cl9pbml0ID0geworCS5sc20gPSBMQU5ETE9DS19OQU1FLAorfTsKKwogc3RhdGljIGludCBfX2lu aXQgbGFuZGxvY2tfaW5pdCh2b2lkKQogewogCWxhbmRsb2NrX2FkZF9jcmVkX2hvb2tzKCk7CmRp ZmYgLS1naXQgYS9zZWN1cml0eS9sYW5kbG9jay9zZXR1cC5oIGIvc2VjdXJpdHkvbGFuZGxvY2sv c2V0dXAuaAppbmRleCAxZGFmZmFiMWFiNGIuLjM4YmNlNWIxNzJkYyAxMDA2NDQKLS0tIGEvc2Vj dXJpdHkvbGFuZGxvY2svc2V0dXAuaAorKysgYi9zZWN1cml0eS9sYW5kbG9jay9zZXR1cC5oCkBA IC0xNCw1ICsxNCw2IEBACiBleHRlcm4gYm9vbCBsYW5kbG9ja19pbml0aWFsaXplZDsKIAogZXh0 ZXJuIHN0cnVjdCBsc21fYmxvYl9zaXplcyBsYW5kbG9ja19ibG9iX3NpemVzOworZXh0ZXJuIHN0 cnVjdCBsc21faWQgbGFuZGxvY2tfbHNtaWQ7CiAKICNlbmRpZiAvKiBfU0VDVVJJVFlfTEFORExP Q0tfU0VUVVBfSCAqLwpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkvbG9hZHBpbi9sb2FkcGluLmMgYi9z ZWN1cml0eS9sb2FkcGluL2xvYWRwaW4uYwppbmRleCBiMTJmN2Q5ODZiMWUuLmI1NjlmM2JjMTcw YiAxMDA2NDQKLS0tIGEvc2VjdXJpdHkvbG9hZHBpbi9sb2FkcGluLmMKKysrIGIvc2VjdXJpdHkv bG9hZHBpbi9sb2FkcGluLmMKQEAgLTE5Miw2ICsxOTIsMTEgQEAgc3RhdGljIGludCBsb2FkcGlu X2xvYWRfZGF0YShlbnVtIGtlcm5lbF9sb2FkX2RhdGFfaWQgaWQsIGJvb2wgY29udGVudHMpCiAJ cmV0dXJuIGxvYWRwaW5fcmVhZF9maWxlKE5VTEwsIChlbnVtIGtlcm5lbF9yZWFkX2ZpbGVfaWQp IGlkLCBjb250ZW50cyk7CiB9CiAKK3N0YXRpYyBzdHJ1Y3QgbHNtX2lkIGxvYWRwaW5fbHNtaWQg X19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKKwkubHNtICA9ICJsb2FkcGluIiwKKwkuc2xvdCA9IExT TUJMT0JfTk9UX05FRURFRAorfTsKKwogc3RhdGljIHN0cnVjdCBzZWN1cml0eV9ob29rX2xpc3Qg bG9hZHBpbl9ob29rc1tdIF9fbHNtX3JvX2FmdGVyX2luaXQgPSB7CiAJTFNNX0hPT0tfSU5JVChz Yl9mcmVlX3NlY3VyaXR5LCBsb2FkcGluX3NiX2ZyZWVfc2VjdXJpdHkpLAogCUxTTV9IT09LX0lO SVQoa2VybmVsX3JlYWRfZmlsZSwgbG9hZHBpbl9yZWFkX2ZpbGUpLApAQCAtMjM5LDcgKzI0NCw4 IEBAIHN0YXRpYyBpbnQgX19pbml0IGxvYWRwaW5faW5pdCh2b2lkKQogCXByX2luZm8oInJlYWR5 IHRvIHBpbiAoY3VycmVudGx5ICVzZW5mb3JjaW5nKVxuIiwKIAkJZW5mb3JjZSA/ICIiIDogIm5v dCAiKTsKIAlwYXJzZV9leGNsdWRlKCk7Ci0Jc2VjdXJpdHlfYWRkX2hvb2tzKGxvYWRwaW5faG9v a3MsIEFSUkFZX1NJWkUobG9hZHBpbl9ob29rcyksICJsb2FkcGluIik7CisJc2VjdXJpdHlfYWRk X2hvb2tzKGxvYWRwaW5faG9va3MsIEFSUkFZX1NJWkUobG9hZHBpbl9ob29rcyksCisJCQkgICAm bG9hZHBpbl9sc21pZCk7CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL3NlY3VyaXR5L2xv Y2tkb3duL2xvY2tkb3duLmMgYi9zZWN1cml0eS9sb2NrZG93bi9sb2NrZG93bi5jCmluZGV4IDg3 Y2JkYzY0ZDI3Mi4uNGUyNGVhM2Y3YjdlIDEwMDY0NAotLS0gYS9zZWN1cml0eS9sb2NrZG93bi9s b2NrZG93bi5jCisrKyBiL3NlY3VyaXR5L2xvY2tkb3duL2xvY2tkb3duLmMKQEAgLTc1LDYgKzc1 LDExIEBAIHN0YXRpYyBzdHJ1Y3Qgc2VjdXJpdHlfaG9va19saXN0IGxvY2tkb3duX2hvb2tzW10g X19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKIAlMU01fSE9PS19JTklUKGxvY2tlZF9kb3duLCBsb2Nr ZG93bl9pc19sb2NrZWRfZG93biksCiB9OwogCitzdGF0aWMgc3RydWN0IGxzbV9pZCBsb2NrZG93 bl9sc21pZCBfX2xzbV9yb19hZnRlcl9pbml0ID0geworCS5sc20gPSAibG9ja2Rvd24iLAorCS5z bG90ID0gTFNNQkxPQl9OT1RfTkVFREVECit9OworCiBzdGF0aWMgaW50IF9faW5pdCBsb2NrZG93 bl9sc21faW5pdCh2b2lkKQogewogI2lmIGRlZmluZWQoQ09ORklHX0xPQ0tfRE9XTl9LRVJORUxf Rk9SQ0VfSU5URUdSSVRZKQpAQCAtODMsNyArODgsNyBAQCBzdGF0aWMgaW50IF9faW5pdCBsb2Nr ZG93bl9sc21faW5pdCh2b2lkKQogCWxvY2tfa2VybmVsX2Rvd24oIktlcm5lbCBjb25maWd1cmF0 aW9uIiwgTE9DS0RPV05fQ09ORklERU5USUFMSVRZX01BWCk7CiAjZW5kaWYKIAlzZWN1cml0eV9h ZGRfaG9va3MobG9ja2Rvd25faG9va3MsIEFSUkFZX1NJWkUobG9ja2Rvd25faG9va3MpLAotCQkJ ICAgImxvY2tkb3duIik7CisJCQkgICAmbG9ja2Rvd25fbHNtaWQpOwogCXJldHVybiAwOwogfQog CmRpZmYgLS1naXQgYS9zZWN1cml0eS9zYWZlc2V0aWQvbHNtLmMgYi9zZWN1cml0eS9zYWZlc2V0 aWQvbHNtLmMKaW5kZXggMTA3OWM2ZDU0Nzg0Li5hMmEyZjQ2MmE4MjEgMTAwNjQ0Ci0tLSBhL3Nl Y3VyaXR5L3NhZmVzZXRpZC9sc20uYworKysgYi9zZWN1cml0eS9zYWZlc2V0aWQvbHNtLmMKQEAg LTI0MSw2ICsyNDEsMTEgQEAgc3RhdGljIGludCBzYWZlc2V0aWRfdGFza19maXhfc2V0Z2lkKHN0 cnVjdCBjcmVkICpuZXcsCiAJcmV0dXJuIC1FQUNDRVM7CiB9CiAKK3N0YXRpYyBzdHJ1Y3QgbHNt X2lkIHNhZmVzZXRpZF9sc21pZCBfX2xzbV9yb19hZnRlcl9pbml0ID0geworCS5sc20gID0gInNh ZmVzZXRpZCIsCisJLnNsb3QgPSBMU01CTE9CX05PVF9ORUVERUQKK307CisKIHN0YXRpYyBzdHJ1 Y3Qgc2VjdXJpdHlfaG9va19saXN0IHNhZmVzZXRpZF9zZWN1cml0eV9ob29rc1tdID0gewogCUxT TV9IT09LX0lOSVQodGFza19maXhfc2V0dWlkLCBzYWZlc2V0aWRfdGFza19maXhfc2V0dWlkKSwK IAlMU01fSE9PS19JTklUKHRhc2tfZml4X3NldGdpZCwgc2FmZXNldGlkX3Rhc2tfZml4X3NldGdp ZCksCkBAIC0yNTAsNyArMjU1LDggQEAgc3RhdGljIHN0cnVjdCBzZWN1cml0eV9ob29rX2xpc3Qg c2FmZXNldGlkX3NlY3VyaXR5X2hvb2tzW10gPSB7CiBzdGF0aWMgaW50IF9faW5pdCBzYWZlc2V0 aWRfc2VjdXJpdHlfaW5pdCh2b2lkKQogewogCXNlY3VyaXR5X2FkZF9ob29rcyhzYWZlc2V0aWRf c2VjdXJpdHlfaG9va3MsCi0JCQkgICBBUlJBWV9TSVpFKHNhZmVzZXRpZF9zZWN1cml0eV9ob29r cyksICJzYWZlc2V0aWQiKTsKKwkJCSAgIEFSUkFZX1NJWkUoc2FmZXNldGlkX3NlY3VyaXR5X2hv b2tzKSwKKwkJCSAgICZzYWZlc2V0aWRfbHNtaWQpOwogCiAJLyogUmVwb3J0IHRoYXQgU2FmZVNl dElEIHN1Y2Nlc3NmdWxseSBpbml0aWFsaXplZCAqLwogCXNhZmVzZXRpZF9pbml0aWFsaXplZCA9 IDE7CmRpZmYgLS1naXQgYS9zZWN1cml0eS9zZWN1cml0eS5jIGIvc2VjdXJpdHkvc2VjdXJpdHku YwppbmRleCBlMTJhN2M0NjM0NjguLmEzMjc2ZGViMWI4YSAxMDA2NDQKLS0tIGEvc2VjdXJpdHkv c2VjdXJpdHkuYworKysgYi9zZWN1cml0eS9zZWN1cml0eS5jCkBAIC0zNDQsNiArMzQ0LDcgQEAg c3RhdGljIHZvaWQgX19pbml0IG9yZGVyZWRfbHNtX2luaXQodm9pZCkKIAlpbml0X2RlYnVnKCJz b2NrIGJsb2Igc2l6ZSAgICAgICA9ICVkXG4iLCBibG9iX3NpemVzLmxic19zb2NrKTsKIAlpbml0 X2RlYnVnKCJzdXBlcmJsb2NrIGJsb2Igc2l6ZSA9ICVkXG4iLCBibG9iX3NpemVzLmxic19zdXBl cmJsb2NrKTsKIAlpbml0X2RlYnVnKCJ0YXNrIGJsb2Igc2l6ZSAgICAgICA9ICVkXG4iLCBibG9i X3NpemVzLmxic190YXNrKTsKKwlpbml0X2RlYnVnKCJsc21ibG9iIHNpemUgICAgICAgICA9ICV6 dVxuIiwgc2l6ZW9mKHN0cnVjdCBsc21ibG9iKSk7CiAKIAkvKgogCSAqIENyZWF0ZSBhbnkga21l bV9jYWNoZXMgbmVlZGVkIGZvciBibG9icwpAQCAtNDcxLDIxICs0NzIsMzYgQEAgc3RhdGljIGlu dCBsc21fYXBwZW5kKGNvbnN0IGNoYXIgKm5ldywgY2hhciAqKnJlc3VsdCkKIAlyZXR1cm4gMDsK IH0KIAorLyoKKyAqIEN1cnJlbnQgaW5kZXggdG8gdXNlIHdoaWxlIGluaXRpYWxpemluZyB0aGUg bHNtYmxvYiBzZWNpZCBsaXN0LgorICovCitzdGF0aWMgaW50IGxzbV9zbG90IF9fbHNtX3JvX2Fm dGVyX2luaXQ7CisKIC8qKgogICogc2VjdXJpdHlfYWRkX2hvb2tzIC0gQWRkIGEgbW9kdWxlcyBo b29rcyB0byB0aGUgaG9vayBsaXN0cy4KICAqIEBob29rczogdGhlIGhvb2tzIHRvIGFkZAogICog QGNvdW50OiB0aGUgbnVtYmVyIG9mIGhvb2tzIHRvIGFkZAotICogQGxzbTogdGhlIG5hbWUgb2Yg dGhlIHNlY3VyaXR5IG1vZHVsZQorICogQGxzbWlkOiB0aGUgaWRlbnRpZmljYXRpb24gaW5mb3Jt YXRpb24gZm9yIHRoZSBzZWN1cml0eSBtb2R1bGUKICAqCiAgKiBFYWNoIExTTSBoYXMgdG8gcmVn aXN0ZXIgaXRzIGhvb2tzIHdpdGggdGhlIGluZnJhc3RydWN0dXJlLgorICogSWYgdGhlIExTTSBp cyB1c2luZyBob29rcyB0aGF0IGV4cG9ydCBzZWNpZHMgYWxsb2NhdGUgYSBzbG90CisgKiBmb3Ig aXQgaW4gdGhlIGxzbWJsb2IuCiAgKi8KIHZvaWQgX19pbml0IHNlY3VyaXR5X2FkZF9ob29rcyhz dHJ1Y3Qgc2VjdXJpdHlfaG9va19saXN0ICpob29rcywgaW50IGNvdW50LAotCQkJCWNoYXIgKmxz bSkKKwkJCSAgICAgICBzdHJ1Y3QgbHNtX2lkICpsc21pZCkKIHsKIAlpbnQgaTsKIAorCWlmIChs c21pZC0+c2xvdCA9PSBMU01CTE9CX05FRURFRCkgeworCQlpZiAobHNtX3Nsb3QgPj0gTFNNQkxP Ql9FTlRSSUVTKQorCQkJcGFuaWMoIiVzIFRvbyBtYW55IExTTXMgcmVnaXN0ZXJlZC5cbiIsIF9f ZnVuY19fKTsKKwkJbHNtaWQtPnNsb3QgPSBsc21fc2xvdCsrOworCQlpbml0X2RlYnVnKCIlcyBh c3NpZ25lZCBsc21ibG9iIHNsb3QgJWRcbiIsIGxzbWlkLT5sc20sCisJCQkgICBsc21pZC0+c2xv dCk7CisJfQorCiAJZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspIHsKLQkJaG9va3NbaV0ubHNt ID0gbHNtOworCQlob29rc1tpXS5sc21pZCA9IGxzbWlkOwogCQlobGlzdF9hZGRfdGFpbF9yY3Uo Jmhvb2tzW2ldLmxpc3QsIGhvb2tzW2ldLmhlYWQpOwogCX0KIApAQCAtNDk0LDcgKzUxMCw3IEBA IHZvaWQgX19pbml0IHNlY3VyaXR5X2FkZF9ob29rcyhzdHJ1Y3Qgc2VjdXJpdHlfaG9va19saXN0 ICpob29rcywgaW50IGNvdW50LAogCSAqIGFuZCBmaXggdGhpcyB1cCBhZnRlcndhcmRzLgogCSAq LwogCWlmIChzbGFiX2lzX2F2YWlsYWJsZSgpKSB7Ci0JCWlmIChsc21fYXBwZW5kKGxzbSwgJmxz bV9uYW1lcykgPCAwKQorCQlpZiAobHNtX2FwcGVuZChsc21pZC0+bHNtLCAmbHNtX25hbWVzKSA8 IDApCiAJCQlwYW5pYygiJXMgLSBDYW5ub3QgZ2V0IGVhcmx5IG1lbW9yeS5cbiIsIF9fZnVuY19f KTsKIAl9CiB9CkBAIC0yMDcwLDcgKzIwODYsNyBAQCBpbnQgc2VjdXJpdHlfZ2V0cHJvY2F0dHIo c3RydWN0IHRhc2tfc3RydWN0ICpwLCBjb25zdCBjaGFyICpsc20sIGNoYXIgKm5hbWUsCiAJc3Ry dWN0IHNlY3VyaXR5X2hvb2tfbGlzdCAqaHA7CiAKIAlobGlzdF9mb3JfZWFjaF9lbnRyeShocCwg JnNlY3VyaXR5X2hvb2tfaGVhZHMuZ2V0cHJvY2F0dHIsIGxpc3QpIHsKLQkJaWYgKGxzbSAhPSBO VUxMICYmIHN0cmNtcChsc20sIGhwLT5sc20pKQorCQlpZiAobHNtICE9IE5VTEwgJiYgc3RyY21w KGxzbSwgaHAtPmxzbWlkLT5sc20pKQogCQkJY29udGludWU7CiAJCXJldHVybiBocC0+aG9vay5n ZXRwcm9jYXR0cihwLCBuYW1lLCB2YWx1ZSk7CiAJfQpAQCAtMjA4Myw3ICsyMDk5LDcgQEAgaW50 IHNlY3VyaXR5X3NldHByb2NhdHRyKGNvbnN0IGNoYXIgKmxzbSwgY29uc3QgY2hhciAqbmFtZSwg dm9pZCAqdmFsdWUsCiAJc3RydWN0IHNlY3VyaXR5X2hvb2tfbGlzdCAqaHA7CiAKIAlobGlzdF9m b3JfZWFjaF9lbnRyeShocCwgJnNlY3VyaXR5X2hvb2tfaGVhZHMuc2V0cHJvY2F0dHIsIGxpc3Qp IHsKLQkJaWYgKGxzbSAhPSBOVUxMICYmIHN0cmNtcChsc20sIGhwLT5sc20pKQorCQlpZiAobHNt ICE9IE5VTEwgJiYgc3RyY21wKGxzbSwgaHAtPmxzbWlkLT5sc20pKQogCQkJY29udGludWU7CiAJ CXJldHVybiBocC0+aG9vay5zZXRwcm9jYXR0cihuYW1lLCB2YWx1ZSwgc2l6ZSk7CiAJfQpAQCAt MjU3Niw3ICsyNTkyLDI0IEBAIGludCBzZWN1cml0eV9rZXlfZ2V0c2VjdXJpdHkoc3RydWN0IGtl eSAqa2V5LCBjaGFyICoqX2J1ZmZlcikKIAogaW50IHNlY3VyaXR5X2F1ZGl0X3J1bGVfaW5pdCh1 MzIgZmllbGQsIHUzMiBvcCwgY2hhciAqcnVsZXN0ciwgdm9pZCAqKmxzbXJ1bGUpCiB7Ci0JcmV0 dXJuIGNhbGxfaW50X2hvb2soYXVkaXRfcnVsZV9pbml0LCAwLCBmaWVsZCwgb3AsIHJ1bGVzdHIs IGxzbXJ1bGUpOworCXN0cnVjdCBzZWN1cml0eV9ob29rX2xpc3QgKmhwOworCWJvb2wgb25lX2lz X2dvb2QgPSBmYWxzZTsKKwlpbnQgcmMgPSAwOworCWludCB0cmM7CisKKwlobGlzdF9mb3JfZWFj aF9lbnRyeShocCwgJnNlY3VyaXR5X2hvb2tfaGVhZHMuYXVkaXRfcnVsZV9pbml0LCBsaXN0KSB7 CisJCWlmIChXQVJOX09OKGhwLT5sc21pZC0+c2xvdCA8IDAgfHwgaHAtPmxzbWlkLT5zbG90ID49 IGxzbV9zbG90KSkKKwkJCWNvbnRpbnVlOworCQl0cmMgPSBocC0+aG9vay5hdWRpdF9ydWxlX2lu aXQoZmllbGQsIG9wLCBydWxlc3RyLAorCQkJCQkgICAgICAgJmxzbXJ1bGVbaHAtPmxzbWlkLT5z bG90XSk7CisJCWlmICh0cmMgPT0gMCkKKwkJCW9uZV9pc19nb29kID0gdHJ1ZTsKKwkJZWxzZQor CQkJcmMgPSB0cmM7CisJfQorCWlmIChvbmVfaXNfZ29vZCkKKwkJcmV0dXJuIDA7CisJcmV0dXJu IHJjOwogfQogCiBpbnQgc2VjdXJpdHlfYXVkaXRfcnVsZV9rbm93bihzdHJ1Y3QgYXVkaXRfa3J1 bGUgKmtydWxlKQpAQCAtMjU4NCwxNCArMjYxNywzMSBAQCBpbnQgc2VjdXJpdHlfYXVkaXRfcnVs ZV9rbm93bihzdHJ1Y3QgYXVkaXRfa3J1bGUgKmtydWxlKQogCXJldHVybiBjYWxsX2ludF9ob29r KGF1ZGl0X3J1bGVfa25vd24sIDAsIGtydWxlKTsKIH0KIAotdm9pZCBzZWN1cml0eV9hdWRpdF9y dWxlX2ZyZWUodm9pZCAqbHNtcnVsZSkKK3ZvaWQgc2VjdXJpdHlfYXVkaXRfcnVsZV9mcmVlKHZv aWQgKipsc21ydWxlKQogewotCWNhbGxfdm9pZF9ob29rKGF1ZGl0X3J1bGVfZnJlZSwgbHNtcnVs ZSk7CisJc3RydWN0IHNlY3VyaXR5X2hvb2tfbGlzdCAqaHA7CisKKwlobGlzdF9mb3JfZWFjaF9l bnRyeShocCwgJnNlY3VyaXR5X2hvb2tfaGVhZHMuYXVkaXRfcnVsZV9mcmVlLCBsaXN0KSB7CisJ CWlmIChXQVJOX09OKGhwLT5sc21pZC0+c2xvdCA8IDAgfHwgaHAtPmxzbWlkLT5zbG90ID49IGxz bV9zbG90KSkKKwkJCWNvbnRpbnVlOworCQlocC0+aG9vay5hdWRpdF9ydWxlX2ZyZWUobHNtcnVs ZVtocC0+bHNtaWQtPnNsb3RdKTsKKwl9CiB9CiAKLWludCBzZWN1cml0eV9hdWRpdF9ydWxlX21h dGNoKHUzMiBzZWNpZCwgdTMyIGZpZWxkLCB1MzIgb3AsIHZvaWQgKmxzbXJ1bGUpCitpbnQgc2Vj dXJpdHlfYXVkaXRfcnVsZV9tYXRjaCh1MzIgc2VjaWQsIHUzMiBmaWVsZCwgdTMyIG9wLCB2b2lk ICoqbHNtcnVsZSkKIHsKLQlyZXR1cm4gY2FsbF9pbnRfaG9vayhhdWRpdF9ydWxlX21hdGNoLCAw LCBzZWNpZCwgZmllbGQsIG9wLCBsc21ydWxlKTsKKwlzdHJ1Y3Qgc2VjdXJpdHlfaG9va19saXN0 ICpocDsKKwlpbnQgcmM7CisKKwlobGlzdF9mb3JfZWFjaF9lbnRyeShocCwgJnNlY3VyaXR5X2hv b2tfaGVhZHMuYXVkaXRfcnVsZV9tYXRjaCwgbGlzdCkgeworCQlpZiAoV0FSTl9PTihocC0+bHNt aWQtPnNsb3QgPCAwIHx8IGhwLT5sc21pZC0+c2xvdCA+PSBsc21fc2xvdCkpCisJCQljb250aW51 ZTsKKwkJcmMgPSBocC0+aG9vay5hdWRpdF9ydWxlX21hdGNoKHNlY2lkLCBmaWVsZCwgb3AsCisJ CQkJCSAgICAgICAmbHNtcnVsZVtocC0+bHNtaWQtPnNsb3RdKTsKKwkJaWYgKHJjKQorCQkJcmV0 dXJuIHJjOworCX0KKwlyZXR1cm4gMDsKIH0KICNlbmRpZiAvKiBDT05GSUdfQVVESVQgKi8KIApk aWZmIC0tZ2l0IGEvc2VjdXJpdHkvc2VsaW51eC9ob29rcy5jIGIvc2VjdXJpdHkvc2VsaW51eC9o b29rcy5jCmluZGV4IDg0ZGRjZWM2MzIyZS4uMDEzM2IxNDJlOTM4IDEwMDY0NAotLS0gYS9zZWN1 cml0eS9zZWxpbnV4L2hvb2tzLmMKKysrIGIvc2VjdXJpdHkvc2VsaW51eC9ob29rcy5jCkBAIC03 MTExLDYgKzcxMTEsMTEgQEAgc3RhdGljIGludCBzZWxpbnV4X3BlcmZfZXZlbnRfd3JpdGUoc3Ry dWN0IHBlcmZfZXZlbnQgKmV2ZW50KQogfQogI2VuZGlmCiAKK3N0YXRpYyBzdHJ1Y3QgbHNtX2lk IHNlbGludXhfbHNtaWQgX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKKwkubHNtICA9ICJzZWxpbnV4 IiwKKwkuc2xvdCA9IExTTUJMT0JfTkVFREVECit9OworCiAvKgogICogSU1QT1JUQU5UIE5PVEU6 IFdoZW4gYWRkaW5nIG5ldyBob29rcywgcGxlYXNlIGJlIGNhcmVmdWwgdG8ga2VlcCB0aGlzIG9y ZGVyOgogICogMS4gYW55IGhvb2tzIHRoYXQgZG9uJ3QgYmVsb25nIHRvICgyLikgb3IgKDMuKSBi ZWxvdywKQEAgLTc0MjQsNyArNzQyOSw4IEBAIHN0YXRpYyBfX2luaXQgaW50IHNlbGludXhfaW5p dCh2b2lkKQogCiAJaGFzaHRhYl9jYWNoZV9pbml0KCk7CiAKLQlzZWN1cml0eV9hZGRfaG9va3Mo c2VsaW51eF9ob29rcywgQVJSQVlfU0laRShzZWxpbnV4X2hvb2tzKSwgInNlbGludXgiKTsKKwlz ZWN1cml0eV9hZGRfaG9va3Moc2VsaW51eF9ob29rcywgQVJSQVlfU0laRShzZWxpbnV4X2hvb2tz KSwKKwkJCSAgICZzZWxpbnV4X2xzbWlkKTsKIAogCWlmIChhdmNfYWRkX2NhbGxiYWNrKHNlbGlu dXhfbmV0Y2FjaGVfYXZjX2NhbGxiYWNrLCBBVkNfQ0FMTEJBQ0tfUkVTRVQpKQogCQlwYW5pYygi U0VMaW51eDogVW5hYmxlIHRvIHJlZ2lzdGVyIEFWQyBuZXRjYWNoZSBjYWxsYmFja1xuIik7CmRp ZmYgLS1naXQgYS9zZWN1cml0eS9zbWFjay9zbWFja19sc20uYyBiL3NlY3VyaXR5L3NtYWNrL3Nt YWNrX2xzbS5jCmluZGV4IDFlZTBiZjE0OTNmNi4uNWMxMGFkMjdiZTM3IDEwMDY0NAotLS0gYS9z ZWN1cml0eS9zbWFjay9zbWFja19sc20uYworKysgYi9zZWN1cml0eS9zbWFjay9zbWFja19sc20u YwpAQCAtNDY5NCw2ICs0Njk0LDExIEBAIHN0cnVjdCBsc21fYmxvYl9zaXplcyBzbWFja19ibG9i X3NpemVzIF9fbHNtX3JvX2FmdGVyX2luaXQgPSB7CiAJLmxic19zdXBlcmJsb2NrID0gc2l6ZW9m KHN0cnVjdCBzdXBlcmJsb2NrX3NtYWNrKSwKIH07CiAKK3N0YXRpYyBzdHJ1Y3QgbHNtX2lkIHNt YWNrX2xzbWlkIF9fbHNtX3JvX2FmdGVyX2luaXQgPSB7CisJLmxzbSAgPSAic21hY2siLAorCS5z bG90ID0gTFNNQkxPQl9ORUVERUQKK307CisKIHN0YXRpYyBzdHJ1Y3Qgc2VjdXJpdHlfaG9va19s aXN0IHNtYWNrX2hvb2tzW10gX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKIAlMU01fSE9PS19JTklU KHB0cmFjZV9hY2Nlc3NfY2hlY2ssIHNtYWNrX3B0cmFjZV9hY2Nlc3NfY2hlY2spLAogCUxTTV9I T09LX0lOSVQocHRyYWNlX3RyYWNlbWUsIHNtYWNrX3B0cmFjZV90cmFjZW1lKSwKQEAgLTQ4OTMs NyArNDg5OCw3IEBAIHN0YXRpYyBfX2luaXQgaW50IHNtYWNrX2luaXQodm9pZCkKIAkvKgogCSAq IFJlZ2lzdGVyIHdpdGggTFNNCiAJICovCi0Jc2VjdXJpdHlfYWRkX2hvb2tzKHNtYWNrX2hvb2tz LCBBUlJBWV9TSVpFKHNtYWNrX2hvb2tzKSwgInNtYWNrIik7CisJc2VjdXJpdHlfYWRkX2hvb2tz KHNtYWNrX2hvb2tzLCBBUlJBWV9TSVpFKHNtYWNrX2hvb2tzKSwgJnNtYWNrX2xzbWlkKTsKIAlz bWFja19lbmFibGVkID0gMTsKIAogCXByX2luZm8oIlNtYWNrOiAgSW5pdGlhbGl6aW5nLlxuIik7 CmRpZmYgLS1naXQgYS9zZWN1cml0eS90b21veW8vdG9tb3lvLmMgYi9zZWN1cml0eS90b21veW8v dG9tb3lvLmMKaW5kZXggMWYzY2Q0MzJkODMwLi4yMmY2MmM2N2YyZWMgMTAwNjQ0Ci0tLSBhL3Nl Y3VyaXR5L3RvbW95by90b21veW8uYworKysgYi9zZWN1cml0eS90b21veW8vdG9tb3lvLmMKQEAg LTUyMyw2ICs1MjMsMTEgQEAgc3RhdGljIHZvaWQgdG9tb3lvX3Rhc2tfZnJlZShzdHJ1Y3QgdGFz a19zdHJ1Y3QgKnRhc2spCiAJfQogfQogCitzdGF0aWMgc3RydWN0IGxzbV9pZCB0b21veW9fbHNt aWQgX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKKwkubHNtICA9ICJ0b21veW8iLAorCS5zbG90ID0g TFNNQkxPQl9OT1RfTkVFREVECit9OworCiAvKgogICogdG9tb3lvX3NlY3VyaXR5X29wcyBpcyBh ICJzdHJ1Y3Qgc2VjdXJpdHlfb3BlcmF0aW9ucyIgd2hpY2ggaXMgdXNlZCBmb3IKICAqIHJlZ2lz dGVyaW5nIFRPTU9ZTy4KQEAgLTU3NSw3ICs1ODAsOCBAQCBzdGF0aWMgaW50IF9faW5pdCB0b21v eW9faW5pdCh2b2lkKQogCXN0cnVjdCB0b21veW9fdGFzayAqcyA9IHRvbW95b190YXNrKGN1cnJl bnQpOwogCiAJLyogcmVnaXN0ZXIgb3Vyc2VsdmVzIHdpdGggdGhlIHNlY3VyaXR5IGZyYW1ld29y ayAqLwotCXNlY3VyaXR5X2FkZF9ob29rcyh0b21veW9faG9va3MsIEFSUkFZX1NJWkUodG9tb3lv X2hvb2tzKSwgInRvbW95byIpOworCXNlY3VyaXR5X2FkZF9ob29rcyh0b21veW9faG9va3MsIEFS UkFZX1NJWkUodG9tb3lvX2hvb2tzKSwKKwkJCSAgICZ0b21veW9fbHNtaWQpOwogCXByX2luZm8o IlRPTU9ZTyBMaW51eCBpbml0aWFsaXplZFxuIik7CiAJcy0+ZG9tYWluX2luZm8gPSAmdG9tb3lv X2tlcm5lbF9kb21haW47CiAJYXRvbWljX2luYygmdG9tb3lvX2tlcm5lbF9kb21haW4udXNlcnMp OwpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkveWFtYS95YW1hX2xzbS5jIGIvc2VjdXJpdHkveWFtYS95 YW1hX2xzbS5jCmluZGV4IDA2ZTIyNjE2NmFhYi4uYTk2MzllYTU0MWY3IDEwMDY0NAotLS0gYS9z ZWN1cml0eS95YW1hL3lhbWFfbHNtLmMKKysrIGIvc2VjdXJpdHkveWFtYS95YW1hX2xzbS5jCkBA IC00MjEsNiArNDIxLDExIEBAIHN0YXRpYyBpbnQgeWFtYV9wdHJhY2VfdHJhY2VtZShzdHJ1Y3Qg dGFza19zdHJ1Y3QgKnBhcmVudCkKIAlyZXR1cm4gcmM7CiB9CiAKK3N0YXRpYyBzdHJ1Y3QgbHNt X2lkIHlhbWFfbHNtaWQgX19sc21fcm9fYWZ0ZXJfaW5pdCA9IHsKKwkubHNtICA9ICJ5YW1hIiwK Kwkuc2xvdCA9IExTTUJMT0JfTk9UX05FRURFRAorfTsKKwogc3RhdGljIHN0cnVjdCBzZWN1cml0 eV9ob29rX2xpc3QgeWFtYV9ob29rc1tdIF9fbHNtX3JvX2FmdGVyX2luaXQgPSB7CiAJTFNNX0hP T0tfSU5JVChwdHJhY2VfYWNjZXNzX2NoZWNrLCB5YW1hX3B0cmFjZV9hY2Nlc3NfY2hlY2spLAog CUxTTV9IT09LX0lOSVQocHRyYWNlX3RyYWNlbWUsIHlhbWFfcHRyYWNlX3RyYWNlbWUpLApAQCAt NDc3LDcgKzQ4Miw3IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCB5YW1hX2luaXRfc3lzY3RsKHZvaWQp IHsgfQogc3RhdGljIGludCBfX2luaXQgeWFtYV9pbml0KHZvaWQpCiB7CiAJcHJfaW5mbygiWWFt YTogYmVjb21pbmcgbWluZGZ1bC5cbiIpOwotCXNlY3VyaXR5X2FkZF9ob29rcyh5YW1hX2hvb2tz LCBBUlJBWV9TSVpFKHlhbWFfaG9va3MpLCAieWFtYSIpOworCXNlY3VyaXR5X2FkZF9ob29rcyh5 YW1hX2hvb2tzLCBBUlJBWV9TSVpFKHlhbWFfaG9va3MpLCAmeWFtYV9sc21pZCk7CiAJeWFtYV9p bml0X3N5c2N0bCgpOwogCXJldHVybiAwOwogfQotLSAKMi4yOS4yCgotLQpMaW51eC1hdWRpdCBt YWlsaW5nIGxpc3QKTGludXgtYXVkaXRAcmVkaGF0LmNvbQpodHRwczovL2xpc3RtYW4ucmVkaGF0 LmNvbS9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWF1ZGl0