52 files changed, 882 insertions, 571 deletions
diff --git a/security/apparmor/apparmorfs.c b/security/apparmor/apparmorfs.c
index caaf51dda648..d4fa04d91439 100644
--- a/security/apparmor/apparmorfs.c
+++ b/security/apparmor/apparmorfs.c
@@ -533,7 +533,7 @@ static ssize_t ns_revision_read(struct file *file, char __user *buf,
        long last_read;
        int avail;
-        mutex_lock(&rev->ns->lock);
+        mutex_lock_nested(&rev->ns->lock, rev->ns->level);
        last_read = rev->last_read;
        if (last_read == rev->ns->revision) {
                mutex_unlock(&rev->ns->lock);
@@ -543,7 +543,7 @@ static ssize_t ns_revision_read(struct file *file, char __user *buf,
                                             last_read !=
                                             READ_ONCE(rev->ns->revision)))
                        return -ERESTARTSYS;
-                mutex_lock(&rev->ns->lock);
+                mutex_lock_nested(&rev->ns->lock, rev->ns->level);
        }
        avail = sprintf(buffer, "%ld\n", rev->ns->revision);
@@ -577,7 +577,7 @@ static unsigned int ns_revision_poll(struct file *file, poll_table *pt)
        unsigned int mask = 0;
        if (rev) {
-                mutex_lock(&rev->ns->lock);
+                mutex_lock_nested(&rev->ns->lock, rev->ns->level);
                poll_wait(file, &rev->ns->wait, pt);
                if (rev->last_read < rev->ns->revision)
                        mask |= POLLIN | POLLRDNORM;
@@ -1643,7 +1643,7 @@ static int ns_mkdir_op(struct inode *dir, struct dentry *dentry, umode_t mode)
         */
        inode_unlock(dir);
        error = simple_pin_fs(&aafs_ops, &aafs_mnt, &aafs_count);
-        mutex_lock(&parent->lock);
+        mutex_lock_nested(&parent->lock, parent->level);
        inode_lock_nested(dir, I_MUTEX_PARENT);
        if (error)
                goto out;
@@ -1692,7 +1692,7 @@ static int ns_rmdir_op(struct inode *dir, struct dentry *dentry)
        inode_unlock(dir);
        inode_unlock(dentry->d_inode);
-        mutex_lock(&parent->lock);
+        mutex_lock_nested(&parent->lock, parent->level);
        ns = aa_get_ns(__aa_findn_ns(&parent->sub_ns, dentry->d_name.name,
                                     dentry->d_name.len));
        if (!ns) {
@@ -1747,7 +1747,7 @@ void __aafs_ns_rmdir(struct aa_ns *ns)
                __aafs_profile_rmdir(child);
        list_for_each_entry(sub, &ns->sub_ns, base.list) {
-                mutex_lock(&sub->lock);
+                mutex_lock_nested(&sub->lock, sub->level);
                __aafs_ns_rmdir(sub);
                mutex_unlock(&sub->lock);
        }
@@ -1877,7 +1877,7 @@ int __aafs_ns_mkdir(struct aa_ns *ns, struct dentry *parent, const char *name,
        /* subnamespaces */
        list_for_each_entry(sub, &ns->sub_ns, base.list) {
-                mutex_lock(&sub->lock);
+                mutex_lock_nested(&sub->lock, sub->level);
                error = __aafs_ns_mkdir(sub, ns_subns_dir(ns), NULL, NULL);
                mutex_unlock(&sub->lock);
                if (error)
@@ -1921,7 +1921,7 @@ static struct aa_ns *__next_ns(struct aa_ns *root, struct aa_ns *ns)
        /* is next namespace a child */
        if (!list_empty(&ns->sub_ns)) {
                next = list_first_entry(&ns->sub_ns, typeof(*ns), base.list);
-                mutex_lock(&next->lock);
+                mutex_lock_nested(&next->lock, next->level);
                return next;
        }
@@ -1931,7 +1931,7 @@ static struct aa_ns *__next_ns(struct aa_ns *root, struct aa_ns *ns)
                mutex_unlock(&ns->lock);
                next = list_next_entry(ns, base.list);
                if (!list_entry_is_head(next, &parent->sub_ns, base.list)) {
-                        mutex_lock(&next->lock);
+                        mutex_lock_nested(&next->lock, next->level);
                        return next;
                }
                ns = parent;
@@ -2039,7 +2039,7 @@ static void *p_start(struct seq_file *f, loff_t *pos)
        f->private = root;
        /* find the first profile */
-        mutex_lock(&root->lock);
+        mutex_lock_nested(&root->lock, root->level);
        profile = __first_profile(root, root);
        /* skip to position */
@@ -2451,7 +2451,7 @@ static int __init aa_create_aafs(void)
        aafs_mnt = kern_mount(&aafs_ops);
        if (IS_ERR(aafs_mnt))
                panic("can't set apparmorfs up\n");
-        aafs_mnt->mnt_sb->s_flags &= ~MS_NOUSER;
+        aafs_mnt->mnt_sb->s_flags &= ~SB_NOUSER;
        /* Populate fs tree. */
        error = entry_create_dir(&aa_sfs_entry, NULL);
@@ -2491,7 +2491,7 @@ static int __init aa_create_aafs(void)
        ns_subrevision(root_ns) = dent;
        /* policy tree referenced by magic policy symlink */
-        mutex_lock(&root_ns->lock);
+        mutex_lock_nested(&root_ns->lock, root_ns->level);
        error = __aafs_ns_mkdir(root_ns, aafs_mnt->mnt_root, ".policy",
                                aafs_mnt->mnt_root);
        mutex_unlock(&root_ns->lock);
diff --git a/security/apparmor/domain.c b/security/apparmor/domain.c
index dd754b7850a8..6a54d2ffa840 100644
--- a/security/apparmor/domain.c
+++ b/security/apparmor/domain.c
@@ -305,6 +305,7 @@ static int change_profile_perms(struct aa_profile *profile,
 * __attach_match_ - find an attachment match
 * @name - to match against  (NOT NULL)
 * @head - profile list to walk  (NOT NULL)
+ * @info - info message if there was an error (NOT NULL)
 *
 * Do a linear search on the profiles in the list.  There is a matching
 * preference where an exact match is preferred over a name which uses
@@ -316,28 +317,47 @@ static int change_profile_perms(struct aa_profile *profile,
 * Returns: profile or NULL if no match found
 */
 static struct aa_profile *__attach_match(const char *name,
-                                         struct list_head *head)
+                                         struct list_head *head,
+                                         const char **info)
 {
        int len = 0;
+        bool conflict = false;
        struct aa_profile *profile, *candidate = NULL;
        list_for_each_entry_rcu(profile, head, base.list) {
-                if (profile->label.flags & FLAG_NULL)
+                if (profile->label.flags & FLAG_NULL &&
+                    &profile->label == ns_unconfined(profile->ns))
                        continue;
-                if (profile->xmatch && profile->xmatch_len > len) {
-                        unsigned int state = aa_dfa_match(profile->xmatch,
+                if (profile->xmatch) {
-                                                          DFA_START, name);
+                        if (profile->xmatch_len >= len) {
-                        u32 perm = dfa_user_allow(profile->xmatch, state);
+                                unsigned int state;
-                        /* any accepting state means a valid match. */
+                                u32 perm;
-                        if (perm & MAY_EXEC) {
-                                candidate = profile;
+                                state = aa_dfa_match(profile->xmatch,
-                                len = profile->xmatch_len;
+                                                     DFA_START, name);
+                                perm = dfa_user_allow(profile->xmatch, state);
+                                /* any accepting state means a valid match. */
+                                if (perm & MAY_EXEC) {
+                                        if (profile->xmatch_len == len) {
+                                                conflict = true;
+                                                continue;
+                                        }
+                                        candidate = profile;
+                                        len = profile->xmatch_len;
+                                        conflict = false;
+                                }
                        }
                } else if (!strcmp(profile->base.name, name))
                        /* exact non-re match, no more searching required */
                        return profile;
        }
+        if (conflict) {
+                *info = "conflicting profile attachments";
+                return NULL;
+        }
        return candidate;
 }
@@ -346,16 +366,17 @@ static struct aa_profile *__attach_match(const char *name,
 * @ns: the current namespace  (NOT NULL)
 * @list: list to search  (NOT NULL)
 * @name: the executable name to match against  (NOT NULL)
+ * @info: info message if there was an error
 *
 * Returns: label or NULL if no match found
 */
 static struct aa_label *find_attach(struct aa_ns *ns, struct list_head *list,
-                                    const char *name)
+                                    const char *name, const char **info)
 {
        struct aa_profile *profile;
        rcu_read_lock();
-        profile = aa_get_profile(__attach_match(name, list));
+        profile = aa_get_profile(__attach_match(name, list, info));
        rcu_read_unlock();
        return profile ? &profile->label : NULL;
@@ -448,11 +469,11 @@ static struct aa_label *x_to_label(struct aa_profile *profile,
                if (xindex & AA_X_CHILD)
                        /* released by caller */
                        new = find_attach(ns, &profile->base.profiles,
-                                                name);
+                                          name, info);
                else
                        /* released by caller */
                        new = find_attach(ns, &ns->base.profiles,
-                                                name);
+                                          name, info);
                *lookupname = name;
                break;
        }
@@ -516,7 +537,7 @@ static struct aa_label *profile_transition(struct aa_profile *profile,
        if (profile_unconfined(profile)) {
                new = find_attach(profile->ns, &profile->ns->base.profiles,
-                                  name);
+                                  name, &info);
                if (new) {
                        AA_DEBUG("unconfined attached to new label");
                        return new;
@@ -541,9 +562,21 @@ static struct aa_label *profile_transition(struct aa_profile *profile,
                }
        } else if (COMPLAIN_MODE(profile)) {
                /* no exec permission - learning mode */
-                struct aa_profile *new_profile = aa_new_null_profile(profile,
+                struct aa_profile *new_profile = NULL;
-                                                              false, name,
+                char *n = kstrdup(name, GFP_ATOMIC);
-                                                              GFP_ATOMIC);
+                if (n) {
+                        /* name is ptr into buffer */
+                        long pos = name - buffer;
+                        /* break per cpu buffer hold */
+                        put_buffers(buffer);
+                        new_profile = aa_new_null_profile(profile, false, n,
+                                                          GFP_KERNEL);
+                        get_buffers(buffer);
+                        name = buffer + pos;
+                        strcpy((char *)name, n);
+                        kfree(n);
+                }
                if (!new_profile) {
                        error = -ENOMEM;
                        info = "could not create null profile";
diff --git a/security/apparmor/file.c b/security/apparmor/file.c
index 3382518b87fa..e79bf44396a3 100644
--- a/security/apparmor/file.c
+++ b/security/apparmor/file.c
@@ -226,18 +226,12 @@ static u32 map_old_perms(u32 old)
 struct aa_perms aa_compute_fperms(struct aa_dfa *dfa, unsigned int state,
                                  struct path_cond *cond)
 {
-        struct aa_perms perms;
        /* FIXME: change over to new dfa format
         * currently file perms are encoded in the dfa, new format
         * splits the permissions from the dfa.  This mapping can be
         * done at profile load
         */
-        perms.deny = 0;
+        struct aa_perms perms = { };
-        perms.kill = perms.stop = 0;
-        perms.complain = perms.cond = 0;
-        perms.hide = 0;
-        perms.prompt = 0;
        if (uid_eq(current_fsuid(), cond->uid)) {
                perms.allow = map_old_perms(dfa_user_allow(dfa, state));
diff --git a/security/apparmor/include/audit.h b/security/apparmor/include/audit.h
index 620e81169659..4ac095118717 100644
--- a/security/apparmor/include/audit.h
+++ b/security/apparmor/include/audit.h
@@ -121,17 +121,19 @@ struct apparmor_audit_data {
                /* these entries require a custom callback fn */
                struct {
                        struct aa_label *peer;
-                        struct {
+                        union {
-                                const char *target;
+                                struct {
-                                kuid_t ouid;
+                                        const char *target;
-                        } fs;
+                                        kuid_t ouid;
+                                } fs;
+                                int signal;
+                        };
                };
                struct {
                        struct aa_profile *profile;
                        const char *ns;
                        long pos;
                } iface;
-                int signal;
                struct {
                        int rlim;
                        unsigned long max;
diff --git a/security/apparmor/include/lib.h b/security/apparmor/include/lib.h
index 436b3a722357..6505e1ad9e23 100644
--- a/security/apparmor/include/lib.h
+++ b/security/apparmor/include/lib.h
@@ -19,17 +19,6 @@
 #include "match.h"
-/* Provide our own test for whether a write lock is held for asserts
- * this is because on none SMP systems write_can_lock will always
- * resolve to true, which is what you want for code making decisions
- * based on it, but wrong for asserts checking that the lock is held
- */
-#ifdef CONFIG_SMP
-#define write_is_locked(X) !write_can_lock(X)
-#else
-#define write_is_locked(X) (1)
-#endif /* CONFIG_SMP */
 /*
 * DEBUG remains global (no per profile flag) since it is mostly used in sysctl
 * which is not related to profile accesses.
@@ -97,7 +86,7 @@ static inline unsigned int aa_dfa_null_transition(struct aa_dfa *dfa,
 static inline bool path_mediated_fs(struct dentry *dentry)
 {
-        return !(dentry->d_sb->s_flags & MS_NOUSER);
+        return !(dentry->d_sb->s_flags & SB_NOUSER);
 }
diff --git a/security/apparmor/include/perms.h b/security/apparmor/include/perms.h
index 2b27bb79aec4..d7b7e7115160 100644
--- a/security/apparmor/include/perms.h
+++ b/security/apparmor/include/perms.h
@@ -133,6 +133,9 @@ extern struct aa_perms allperms;
 #define xcheck_labels_profiles(L1, L2, FN, args...)             \
        xcheck_ns_labels((L1), (L2), xcheck_ns_profile_label, (FN), args)
+#define xcheck_labels(L1, L2, P, FN1, FN2)                      \
+        xcheck(fn_for_each((L1), (P), (FN1)), fn_for_each((L2), (P), (FN2)))
 void aa_perm_mask_to_str(char *str, const char *chrs, u32 mask);
 void aa_audit_perm_names(struct audit_buffer *ab, const char **names, u32 mask);
diff --git a/security/apparmor/ipc.c b/security/apparmor/ipc.c
index 7ca0032e7ba9..b40678f3c1d5 100644
--- a/security/apparmor/ipc.c
+++ b/security/apparmor/ipc.c
@@ -64,40 +64,48 @@ static void audit_ptrace_cb(struct audit_buffer *ab, void *va)
                        FLAGS_NONE, GFP_ATOMIC);
 }
+/* assumes check for PROFILE_MEDIATES is already done */
 /* TODO: conditionals */
 static int profile_ptrace_perm(struct aa_profile *profile,
-                               struct aa_profile *peer, u32 request,
+                             struct aa_label *peer, u32 request,
-                               struct common_audit_data *sa)
+                             struct common_audit_data *sa)
 {
        struct aa_perms perms = { };
-        /* need because of peer in cross check */
+        aad(sa)->peer = peer;
-        if (profile_unconfined(profile) ||
+        aa_profile_match_label(profile, peer, AA_CLASS_PTRACE, request,
-            !PROFILE_MEDIATES(profile, AA_CLASS_PTRACE))
-                return 0;
-        aad(sa)->peer = &peer->label;
-        aa_profile_match_label(profile, &peer->label, AA_CLASS_PTRACE, request,
                               &perms);
        aa_apply_modes_to_perms(profile, &perms);
        return aa_check_perms(profile, &perms, request, sa, audit_ptrace_cb);
 }
-static int cross_ptrace_perm(struct aa_profile *tracer,
+static int profile_tracee_perm(struct aa_profile *tracee,
-                             struct aa_profile *tracee, u32 request,
+                               struct aa_label *tracer, u32 request,
-                             struct common_audit_data *sa)
+                               struct common_audit_data *sa)
 {
+        if (profile_unconfined(tracee) || unconfined(tracer) ||
+            !PROFILE_MEDIATES(tracee, AA_CLASS_PTRACE))
+                return 0;
+        return profile_ptrace_perm(tracee, tracer, request, sa);
+}
+static int profile_tracer_perm(struct aa_profile *tracer,
+                               struct aa_label *tracee, u32 request,
+                               struct common_audit_data *sa)
+{
+        if (profile_unconfined(tracer))
+                return 0;
        if (PROFILE_MEDIATES(tracer, AA_CLASS_PTRACE))
-                return xcheck(profile_ptrace_perm(tracer, tracee, request, sa),
+                return profile_ptrace_perm(tracer, tracee, request, sa);
-                              profile_ptrace_perm(tracee, tracer,
-                                                  request << PTRACE_PERM_SHIFT,
+        /* profile uses the old style capability check for ptrace */
-                                                  sa));
+        if (&tracer->label == tracee)
-        /* policy uses the old style capability check for ptrace */
-        if (profile_unconfined(tracer) || tracer == tracee)
                return 0;
        aad(sa)->label = &tracer->label;
-        aad(sa)->peer = &tracee->label;
+        aad(sa)->peer = tracee;
        aad(sa)->request = 0;
        aad(sa)->error = aa_capable(&tracer->label, CAP_SYS_PTRACE, 1);
@@ -115,10 +123,13 @@ static int cross_ptrace_perm(struct aa_profile *tracer,
 int aa_may_ptrace(struct aa_label *tracer, struct aa_label *tracee,
                  u32 request)
 {
+        struct aa_profile *profile;
+        u32 xrequest = request << PTRACE_PERM_SHIFT;
        DEFINE_AUDIT_DATA(sa, LSM_AUDIT_DATA_NONE, OP_PTRACE);
-        return xcheck_labels_profiles(tracer, tracee, cross_ptrace_perm,
+        return xcheck_labels(tracer, tracee, profile,
-                                      request, &sa);
+                        profile_tracer_perm(profile, tracee, request, &sa),
+                        profile_tracee_perm(profile, tracer, xrequest, &sa));
 }
diff --git a/security/apparmor/label.c b/security/apparmor/label.c
index c5b99b954580..324fe5c60f87 100644
--- a/security/apparmor/label.c
+++ b/security/apparmor/label.c
@@ -80,7 +80,7 @@ void __aa_proxy_redirect(struct aa_label *orig, struct aa_label *new)
        AA_BUG(!orig);
        AA_BUG(!new);
-        AA_BUG(!write_is_locked(&labels_set(orig)->lock));
+        lockdep_assert_held_exclusive(&labels_set(orig)->lock);
        tmp = rcu_dereference_protected(orig->proxy->label,
                                        &labels_ns(orig)->lock);
@@ -571,7 +571,7 @@ static bool __label_remove(struct aa_label *label, struct aa_label *new)
        AA_BUG(!ls);
        AA_BUG(!label);
-        AA_BUG(!write_is_locked(&ls->lock));
+        lockdep_assert_held_exclusive(&ls->lock);
        if (new)
                __aa_proxy_redirect(label, new);
@@ -608,7 +608,7 @@ static bool __label_replace(struct aa_label *old, struct aa_label *new)
        AA_BUG(!ls);
        AA_BUG(!old);
        AA_BUG(!new);
-        AA_BUG(!write_is_locked(&ls->lock));
+        lockdep_assert_held_exclusive(&ls->lock);
        AA_BUG(new->flags & FLAG_IN_TREE);
        if (!label_is_stale(old))
@@ -645,7 +645,7 @@ static struct aa_label *__label_insert(struct aa_labelset *ls,
        AA_BUG(!ls);
        AA_BUG(!label);
        AA_BUG(labels_set(label) != ls);
-        AA_BUG(!write_is_locked(&ls->lock));
+        lockdep_assert_held_exclusive(&ls->lock);
        AA_BUG(label->flags & FLAG_IN_TREE);
        /* Figure out where to put new node */
@@ -2115,7 +2115,7 @@ void __aa_labelset_update_subtree(struct aa_ns *ns)
        __labelset_update(ns);
        list_for_each_entry(child, &ns->sub_ns, base.list) {
-                mutex_lock(&child->lock);
+                mutex_lock_nested(&child->lock, child->level);
                __aa_labelset_update_subtree(child);
                mutex_unlock(&child->lock);
        }
diff --git a/security/apparmor/lib.c b/security/apparmor/lib.c
index 08ca26bcca77..4d5e98e49d5e 100644
--- a/security/apparmor/lib.c
+++ b/security/apparmor/lib.c
@@ -317,14 +317,11 @@ static u32 map_other(u32 x)
 void aa_compute_perms(struct aa_dfa *dfa, unsigned int state,
                      struct aa_perms *perms)
 {
-        perms->deny = 0;
+        *perms = (struct aa_perms) {
-        perms->kill = perms->stop = 0;
+                .allow = dfa_user_allow(dfa, state),
-        perms->complain = perms->cond = 0;
+                .audit = dfa_user_audit(dfa, state),
-        perms->hide = 0;
+                .quiet = dfa_user_quiet(dfa, state),
-        perms->prompt = 0;
+        };
-        perms->allow = dfa_user_allow(dfa, state);
-        perms->audit = dfa_user_audit(dfa, state);
-        perms->quiet = dfa_user_quiet(dfa, state);
        /* for v5 perm mapping in the policydb, the other set is used
         * to extend the general perm set
@@ -426,7 +423,6 @@ int aa_check_perms(struct aa_profile *profile, struct aa_perms *perms,
                   void (*cb)(struct audit_buffer *, void *))
 {
        int type, error;
-        bool stop = false;
        u32 denied = request & (~perms->allow | perms->deny);
        if (likely(!denied)) {
@@ -447,8 +443,6 @@ int aa_check_perms(struct aa_profile *profile, struct aa_perms *perms,
                else
                        type = AUDIT_APPARMOR_DENIED;
-                if (denied & perms->stop)
-                        stop = true;
                if (denied == (denied & perms->hide))
                        error = -ENOENT;
diff --git a/security/apparmor/lsm.c b/security/apparmor/lsm.c
index 1346ee5be04f..9a65eeaf7dfa 100644
--- a/security/apparmor/lsm.c
+++ b/security/apparmor/lsm.c
@@ -813,11 +813,11 @@ static const struct kernel_param_ops param_ops_aalockpolicy = {
        .get = param_get_aalockpolicy
 };
-static int param_set_audit(const char *val, struct kernel_param *kp);
+static int param_set_audit(const char *val, const struct kernel_param *kp);
-static int param_get_audit(char *buffer, struct kernel_param *kp);
+static int param_get_audit(char *buffer, const struct kernel_param *kp);
-static int param_set_mode(const char *val, struct kernel_param *kp);
+static int param_set_mode(const char *val, const struct kernel_param *kp);
-static int param_get_mode(char *buffer, struct kernel_param *kp);
+static int param_get_mode(char *buffer, const struct kernel_param *kp);
 /* Flag values, also controllable via /sys/module/apparmor/parameters
 * We define special types as we want to do additional mediation.
@@ -846,7 +846,7 @@ module_param_call(audit, param_set_audit, param_get_audit,
 /* Determines if audit header is included in audited messages.  This
 * provides more context if the audit daemon is not running
 */
-bool aa_g_audit_header = 1;
+bool aa_g_audit_header = true;
 module_param_named(audit_header, aa_g_audit_header, aabool,
                   S_IRUSR | S_IWUSR);
@@ -871,7 +871,7 @@ module_param_named(path_max, aa_g_path_max, aauint, S_IRUSR);
 * DEPRECATED: read only as strict checking of load is always done now
 * that none root users (user namespaces) can load policy.
 */
-bool aa_g_paranoid_load = 1;
+bool aa_g_paranoid_load = true;
 module_param_named(paranoid_load, aa_g_paranoid_load, aabool, S_IRUGO);
 /* Boot time disable flag */
@@ -951,7 +951,7 @@ static int param_get_aauint(char *buffer, const struct kernel_param *kp)
        return param_get_uint(buffer, kp);
 }
-static int param_get_audit(char *buffer, struct kernel_param *kp)
+static int param_get_audit(char *buffer, const struct kernel_param *kp)
 {
        if (!apparmor_enabled)
                return -EINVAL;
@@ -960,7 +960,7 @@ static int param_get_audit(char *buffer, struct kernel_param *kp)
        return sprintf(buffer, "%s", audit_mode_names[aa_g_audit]);
 }
-static int param_set_audit(const char *val, struct kernel_param *kp)
+static int param_set_audit(const char *val, const struct kernel_param *kp)
 {
        int i;
@@ -981,7 +981,7 @@ static int param_set_audit(const char *val, struct kernel_param *kp)
        return -EINVAL;
 }
-static int param_get_mode(char *buffer, struct kernel_param *kp)
+static int param_get_mode(char *buffer, const struct kernel_param *kp)
 {
        if (!apparmor_enabled)
                return -EINVAL;
@@ -991,7 +991,7 @@ static int param_get_mode(char *buffer, struct kernel_param *kp)
        return sprintf(buffer, "%s", aa_profile_mode_names[aa_g_profile_mode]);
 }
-static int param_set_mode(const char *val, struct kernel_param *kp)
+static int param_set_mode(const char *val, const struct kernel_param *kp)
 {
        int i;
@@ -1119,7 +1119,7 @@ static int __init apparmor_init(void)
        if (!apparmor_enabled || !security_module_enable("apparmor")) {
                aa_info_message("AppArmor disabled by boot time parameter");
-                apparmor_enabled = 0;
+                apparmor_enabled = false;
                return 0;
        }
@@ -1175,7 +1175,7 @@ alloc_out:
        aa_destroy_aafs();
        aa_teardown_dfa_engine();
-        apparmor_enabled = 0;
+        apparmor_enabled = false;
        return error;
 }
diff --git a/security/apparmor/mount.c b/security/apparmor/mount.c
index 82a64b58041d..8c558cbce930 100644
--- a/security/apparmor/mount.c
+++ b/security/apparmor/mount.c
@@ -216,13 +216,12 @@ static unsigned int match_mnt_flags(struct aa_dfa *dfa, unsigned int state,
 static struct aa_perms compute_mnt_perms(struct aa_dfa *dfa,
                                           unsigned int state)
 {
-        struct aa_perms perms;
+        struct aa_perms perms = {
+                .allow = dfa_user_allow(dfa, state),
-        perms.kill = 0;
+                .audit = dfa_user_audit(dfa, state),
-        perms.allow = dfa_user_allow(dfa, state);
+                .quiet = dfa_user_quiet(dfa, state),
-        perms.audit = dfa_user_audit(dfa, state);
+                .xindex = dfa_user_xindex(dfa, state),
-        perms.quiet = dfa_user_quiet(dfa, state);
+        };
-        perms.xindex = dfa_user_xindex(dfa, state);
        return perms;
 }
@@ -330,6 +329,9 @@ static int match_mnt_path_str(struct aa_profile *profile,
        AA_BUG(!mntpath);
        AA_BUG(!buffer);
+        if (!PROFILE_MEDIATES(profile, AA_CLASS_MOUNT))
+                return 0;
        error = aa_path_name(mntpath, path_flags(profile, mntpath), buffer,
                             &mntpnt, &info, profile->disconnected);
        if (error)
@@ -381,6 +383,9 @@ static int match_mnt(struct aa_profile *profile, const struct path *path,
        AA_BUG(!profile);
        AA_BUG(devpath && !devbuffer);
+        if (!PROFILE_MEDIATES(profile, AA_CLASS_MOUNT))
+                return 0;
        if (devpath) {
                error = aa_path_name(devpath, path_flags(profile, devpath),
                                     devbuffer, &devname, &info,
@@ -559,6 +564,9 @@ static int profile_umount(struct aa_profile *profile, struct path *path,
        AA_BUG(!profile);
        AA_BUG(!path);
+        if (!PROFILE_MEDIATES(profile, AA_CLASS_MOUNT))
+                return 0;
        error = aa_path_name(path, path_flags(profile, path), buffer, &name,
                             &info, profile->disconnected);
        if (error)
@@ -614,7 +622,8 @@ static struct aa_label *build_pivotroot(struct aa_profile *profile,
        AA_BUG(!new_path);
        AA_BUG(!old_path);
-        if (profile_unconfined(profile))
+        if (profile_unconfined(profile) ||
+            !PROFILE_MEDIATES(profile, AA_CLASS_MOUNT))
                return aa_get_newest_label(&profile->label);
        error = aa_path_name(old_path, path_flags(profile, old_path),
diff --git a/security/apparmor/policy.c b/security/apparmor/policy.c
index 4243b0c3f0e4..b0b58848c248 100644
--- a/security/apparmor/policy.c
+++ b/security/apparmor/policy.c
@@ -502,7 +502,7 @@ struct aa_profile *aa_new_null_profile(struct aa_profile *parent, bool hat,
 {
        struct aa_profile *p, *profile;
        const char *bname;
-        char *name;
+        char *name = NULL;
        AA_BUG(!parent);
@@ -545,7 +545,7 @@ name:
        profile->file.dfa = aa_get_dfa(nulldfa);
        profile->policy.dfa = aa_get_dfa(nulldfa);
-        mutex_lock(&profile->ns->lock);
+        mutex_lock_nested(&profile->ns->lock, profile->ns->level);
        p = __find_child(&parent->base.profiles, bname);
        if (p) {
                aa_free_profile(profile);
@@ -562,6 +562,7 @@ out:
        return profile;
 fail:
+        kfree(name);
        aa_free_profile(profile);
        return NULL;
 }
@@ -905,7 +906,7 @@ ssize_t aa_replace_profiles(struct aa_ns *policy_ns, struct aa_label *label,
        } else
                ns = aa_get_ns(policy_ns ? policy_ns : labels_ns(label));
-        mutex_lock(&ns->lock);
+        mutex_lock_nested(&ns->lock, ns->level);
        /* check for duplicate rawdata blobs: space and file dedup */
        list_for_each_entry(rawdata_ent, &ns->rawdata_list, list) {
                if (aa_rawdata_eq(rawdata_ent, udata)) {
@@ -1116,13 +1117,13 @@ ssize_t aa_remove_profiles(struct aa_ns *policy_ns, struct aa_label *subj,
        if (!name) {
                /* remove namespace - can only happen if fqname[0] == ':' */
-                mutex_lock(&ns->parent->lock);
+                mutex_lock_nested(&ns->parent->lock, ns->level);
                __aa_remove_ns(ns);
                __aa_bump_ns_revision(ns);
                mutex_unlock(&ns->parent->lock);
        } else {
                /* remove profile */
-                mutex_lock(&ns->lock);
+                mutex_lock_nested(&ns->lock, ns->level);
                profile = aa_get_profile(__lookup_profile(&ns->base, name));
                if (!profile) {
                        error = -ENOENT;
diff --git a/security/apparmor/policy_ns.c b/security/apparmor/policy_ns.c
index 62a3589c62ab..b1e629cba70b 100644
--- a/security/apparmor/policy_ns.c
+++ b/security/apparmor/policy_ns.c
@@ -256,7 +256,8 @@ static struct aa_ns *__aa_create_ns(struct aa_ns *parent, const char *name,
        ns = alloc_ns(parent->base.hname, name);
        if (!ns)
                return NULL;
-        mutex_lock(&ns->lock);
+        ns->level = parent->level + 1;
+        mutex_lock_nested(&ns->lock, ns->level);
        error = __aafs_ns_mkdir(ns, ns_subns_dir(parent), name, dir);
        if (error) {
                AA_ERROR("Failed to create interface for ns %s\n",
@@ -266,7 +267,6 @@ static struct aa_ns *__aa_create_ns(struct aa_ns *parent, const char *name,
                return ERR_PTR(error);
        }
        ns->parent = aa_get_ns(parent);
-        ns->level = parent->level + 1;
        list_add_rcu(&ns->base.list, &parent->sub_ns);
        /* add list ref */
        aa_get_ns(ns);
@@ -313,7 +313,7 @@ struct aa_ns *aa_prepare_ns(struct aa_ns *parent, const char *name)
 {
        struct aa_ns *ns;
-        mutex_lock(&parent->lock);
+        mutex_lock_nested(&parent->lock, parent->level);
        /* try and find the specified ns and if it doesn't exist create it */
        /* released by caller */
        ns = aa_get_ns(__aa_find_ns(&parent->sub_ns, name));
@@ -336,7 +336,7 @@ static void destroy_ns(struct aa_ns *ns)
        if (!ns)
                return;
-        mutex_lock(&ns->lock);
+        mutex_lock_nested(&ns->lock, ns->level);
        /* release all profiles in this namespace */
        __aa_profile_list_release(&ns->base.profiles);
diff --git a/security/apparmor/policy_unpack.c b/security/apparmor/policy_unpack.c
index 4ede87c30f8b..59a1a25b7d43 100644
--- a/security/apparmor/policy_unpack.c
+++ b/security/apparmor/policy_unpack.c
@@ -157,7 +157,7 @@ static void do_loaddata_free(struct work_struct *work)
        struct aa_ns *ns = aa_get_ns(d->ns);
        if (ns) {
-                mutex_lock(&ns->lock);
+                mutex_lock_nested(&ns->lock, ns->level);
                __aa_fs_remove_rawdata(d);
                mutex_unlock(&ns->lock);
                aa_put_ns(ns);
diff --git a/security/apparmor/resource.c b/security/apparmor/resource.c
index d8bc842594ed..cf4d234febe9 100644
--- a/security/apparmor/resource.c
+++ b/security/apparmor/resource.c
@@ -47,7 +47,7 @@ static void audit_cb(struct audit_buffer *ab, void *va)
 /**
 * audit_resource - audit setting resource limit
 * @profile: profile being enforced  (NOT NULL)
- * @resoure: rlimit being auditing
+ * @resource: rlimit being auditing
 * @value: value being set
 * @error: error value
 *
@@ -128,7 +128,7 @@ int aa_task_setrlimit(struct aa_label *label, struct task_struct *task,
                error = fn_for_each(label, profile,
                                audit_resource(profile, resource,
                                               new_rlim->rlim_max, peer,
-                                               "cap_sys_resoure", -EACCES));
+                                               "cap_sys_resource", -EACCES));
        else
                error = fn_for_each_confined(label, profile,
                                profile_setrlimit(profile, resource, new_rlim));
diff --git a/security/commoncap.c b/security/commoncap.c
index fc46f5b85251..48620c93d697 100644
--- a/security/commoncap.c
+++ b/security/commoncap.c
@@ -348,21 +348,18 @@ static __u32 sansflags(__u32 m)
        return m & ~VFS_CAP_FLAGS_EFFECTIVE;
 }
-static bool is_v2header(size_t size, __le32 magic)
+static bool is_v2header(size_t size, const struct vfs_cap_data *cap)
 {
-        __u32 m = le32_to_cpu(magic);
        if (size != XATTR_CAPS_SZ_2)
                return false;
-        return sansflags(m) == VFS_CAP_REVISION_2;
+        return sansflags(le32_to_cpu(cap->magic_etc)) == VFS_CAP_REVISION_2;
 }
-static bool is_v3header(size_t size, __le32 magic)
+static bool is_v3header(size_t size, const struct vfs_cap_data *cap)
 {
-        __u32 m = le32_to_cpu(magic);
        if (size != XATTR_CAPS_SZ_3)
                return false;
-        return sansflags(m) == VFS_CAP_REVISION_3;
+        return sansflags(le32_to_cpu(cap->magic_etc)) == VFS_CAP_REVISION_3;
 }
 /*
@@ -405,7 +402,7 @@ int cap_inode_getsecurity(struct inode *inode, const char *name, void **buffer,
        fs_ns = inode->i_sb->s_user_ns;
        cap = (struct vfs_cap_data *) tmpbuf;
-        if (is_v2header((size_t) ret, cap->magic_etc)) {
+        if (is_v2header((size_t) ret, cap)) {
                /* If this is sizeof(vfs_cap_data) then we're ok with the
                 * on-disk value, so return that.  */
                if (alloc)
@@ -413,7 +410,7 @@ int cap_inode_getsecurity(struct inode *inode, const char *name, void **buffer,
                else
                        kfree(tmpbuf);
                return ret;
-        } else if (!is_v3header((size_t) ret, cap->magic_etc)) {
+        } else if (!is_v3header((size_t) ret, cap)) {
                kfree(tmpbuf);
                return -EINVAL;
        }
@@ -470,9 +467,9 @@ static kuid_t rootid_from_xattr(const void *value, size_t size,
        return make_kuid(task_ns, rootid);
 }
-static bool validheader(size_t size, __le32 magic)
+static bool validheader(size_t size, const struct vfs_cap_data *cap)
 {
-        return is_v2header(size, magic) || is_v3header(size, magic);
+        return is_v2header(size, cap) || is_v3header(size, cap);
 }
 /*
@@ -495,7 +492,7 @@ int cap_convert_nscap(struct dentry *dentry, void **ivalue, size_t size)
        if (!*ivalue)
                return -EINVAL;
-        if (!validheader(size, cap->magic_etc))
+        if (!validheader(size, cap))
                return -EINVAL;
        if (!capable_wrt_inode_uidgid(inode, CAP_SETFCAP))
                return -EPERM;
@@ -536,7 +533,7 @@ int cap_convert_nscap(struct dentry *dentry, void **ivalue, size_t size)
 static inline int bprm_caps_from_vfs_caps(struct cpu_vfs_cap_data *caps,
                                          struct linux_binprm *bprm,
                                          bool *effective,
-                                          bool *has_cap)
+                                          bool *has_fcap)
 {
        struct cred *new = bprm->cred;
        unsigned i;
@@ -546,7 +543,7 @@ static inline int bprm_caps_from_vfs_caps(struct cpu_vfs_cap_data *caps,
                *effective = true;
        if (caps->magic_etc & VFS_CAP_REVISION_MASK)
-                *has_cap = true;
+                *has_fcap = true;
        CAP_FOR_EACH_U32(i) {
                __u32 permitted = caps->permitted.cap[i];
@@ -653,7 +650,7 @@ int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data
 * its xattrs and, if present, apply them to the proposed credentials being
 * constructed by execve().
 */
-static int get_file_caps(struct linux_binprm *bprm, bool *effective, bool *has_cap)
+static int get_file_caps(struct linux_binprm *bprm, bool *effective, bool *has_fcap)
 {
        int rc = 0;
        struct cpu_vfs_cap_data vcaps;
@@ -684,7 +681,7 @@ static int get_file_caps(struct linux_binprm *bprm, bool *effective, bool *has_c
                goto out;
        }
-        rc = bprm_caps_from_vfs_caps(&vcaps, bprm, effective, has_cap);
+        rc = bprm_caps_from_vfs_caps(&vcaps, bprm, effective, has_fcap);
        if (rc == -EINVAL)
                printk(KERN_NOTICE "%s: cap_from_disk returned %d for %s\n",
                       __func__, rc, bprm->filename);
@@ -696,6 +693,115 @@ out:
        return rc;
 }
+static inline bool root_privileged(void) { return !issecure(SECURE_NOROOT); }
+static inline bool __is_real(kuid_t uid, struct cred *cred)
+{ return uid_eq(cred->uid, uid); }
+static inline bool __is_eff(kuid_t uid, struct cred *cred)
+{ return uid_eq(cred->euid, uid); }
+static inline bool __is_suid(kuid_t uid, struct cred *cred)
+{ return !__is_real(uid, cred) && __is_eff(uid, cred); }
+/*
+ * handle_privileged_root - Handle case of privileged root
+ * @bprm: The execution parameters, including the proposed creds
+ * @has_fcap: Are any file capabilities set?
+ * @effective: Do we have effective root privilege?
+ * @root_uid: This namespace' root UID WRT initial USER namespace
+ *
+ * Handle the case where root is privileged and hasn't been neutered by
+ * SECURE_NOROOT.  If file capabilities are set, they won't be combined with
+ * set UID root and nothing is changed.  If we are root, cap_permitted is
+ * updated.  If we have become set UID root, the effective bit is set.
+ */
+static void handle_privileged_root(struct linux_binprm *bprm, bool has_fcap,
+                                   bool *effective, kuid_t root_uid)
+{
+        const struct cred *old = current_cred();
+        struct cred *new = bprm->cred;
+        if (!root_privileged())
+                return;
+        /*
+         * If the legacy file capability is set, then don't set privs
+         * for a setuid root binary run by a non-root user.  Do set it
+         * for a root user just to cause least surprise to an admin.
+         */
+        if (has_fcap && __is_suid(root_uid, new)) {
+                warn_setuid_and_fcaps_mixed(bprm->filename);
+                return;
+        }
+        /*
+         * To support inheritance of root-permissions and suid-root
+         * executables under compatibility mode, we override the
+         * capability sets for the file.
+         */
+        if (__is_eff(root_uid, new) || __is_real(root_uid, new)) {
+                /* pP' = (cap_bset & ~0) | (pI & ~0) */
+                new->cap_permitted = cap_combine(old->cap_bset,
+                                                 old->cap_inheritable);
+        }
+        /*
+         * If only the real uid is 0, we do not set the effective bit.
+         */
+        if (__is_eff(root_uid, new))
+                *effective = true;
+}
+#define __cap_gained(field, target, source) \
+        !cap_issubset(target->cap_##field, source->cap_##field)
+#define __cap_grew(target, source, cred) \
+        !cap_issubset(cred->cap_##target, cred->cap_##source)
+#define __cap_full(field, cred) \
+        cap_issubset(CAP_FULL_SET, cred->cap_##field)
+static inline bool __is_setuid(struct cred *new, const struct cred *old)
+{ return !uid_eq(new->euid, old->uid); }
+static inline bool __is_setgid(struct cred *new, const struct cred *old)
+{ return !gid_eq(new->egid, old->gid); }
+/*
+ * 1) Audit candidate if current->cap_effective is set
+ *
+ * We do not bother to audit if 3 things are true:
+ *   1) cap_effective has all caps
+ *   2) we became root *OR* are were already root
+ *   3) root is supposed to have all caps (SECURE_NOROOT)
+ * Since this is just a normal root execing a process.
+ *
+ * Number 1 above might fail if you don't have a full bset, but I think
+ * that is interesting information to audit.
+ *
+ * A number of other conditions require logging:
+ * 2) something prevented setuid root getting all caps
+ * 3) non-setuid root gets fcaps
+ * 4) non-setuid root gets ambient
+ */
+static inline bool nonroot_raised_pE(struct cred *new, const struct cred *old,
+                                     kuid_t root, bool has_fcap)
+{
+        bool ret = false;
+        if ((__cap_grew(effective, ambient, new) &&
+             !(__cap_full(effective, new) &&
+               (__is_eff(root, new) || __is_real(root, new)) &&
+               root_privileged())) ||
+            (root_privileged() &&
+             __is_suid(root, new) &&
+             !__cap_full(effective, new)) ||
+            (!__is_setuid(new, old) &&
+             ((has_fcap &&
+               __cap_gained(permitted, new, old)) ||
+              __cap_gained(ambient, new, old))))
+                ret = true;
+        return ret;
+}
 /**
 * cap_bprm_set_creds - Set up the proposed credentials for execve().
 * @bprm: The execution parameters, including the proposed creds
@@ -708,61 +814,33 @@ int cap_bprm_set_creds(struct linux_binprm *bprm)
 {
        const struct cred *old = current_cred();
        struct cred *new = bprm->cred;
-        bool effective, has_cap = false, is_setid;
+        bool effective = false, has_fcap = false, is_setid;
        int ret;
        kuid_t root_uid;
        if (WARN_ON(!cap_ambient_invariant_ok(old)))
                return -EPERM;
-        effective = false;
+        ret = get_file_caps(bprm, &effective, &has_fcap);
-        ret = get_file_caps(bprm, &effective, &has_cap);
        if (ret < 0)
                return ret;
        root_uid = make_kuid(new->user_ns, 0);
-        if (!issecure(SECURE_NOROOT)) {
+        handle_privileged_root(bprm, has_fcap, &effective, root_uid);
-                /*
-                 * If the legacy file capability is set, then don't set privs
-                 * for a setuid root binary run by a non-root user.  Do set it
-                 * for a root user just to cause least surprise to an admin.
-                 */
-                if (has_cap && !uid_eq(new->uid, root_uid) && uid_eq(new->euid, root_uid)) {
-                        warn_setuid_and_fcaps_mixed(bprm->filename);
-                        goto skip;
-                }
-                /*
-                 * To support inheritance of root-permissions and suid-root
-                 * executables under compatibility mode, we override the
-                 * capability sets for the file.
-                 *
-                 * If only the real uid is 0, we do not set the effective bit.
-                 */
-                if (uid_eq(new->euid, root_uid) || uid_eq(new->uid, root_uid)) {
-                        /* pP' = (cap_bset & ~0) | (pI & ~0) */
-                        new->cap_permitted = cap_combine(old->cap_bset,
-                                                         old->cap_inheritable);
-                }
-                if (uid_eq(new->euid, root_uid))
-                        effective = true;
-        }
-skip:
        /* if we have fs caps, clear dangerous personality flags */
-        if (!cap_issubset(new->cap_permitted, old->cap_permitted))
+        if (__cap_gained(permitted, new, old))
                bprm->per_clear |= PER_CLEAR_ON_SETID;
        /* Don't let someone trace a set[ug]id/setpcap binary with the revised
         * credentials unless they have the appropriate permit.
         *
         * In addition, if NO_NEW_PRIVS, then ensure we get no new privs.
         */
-        is_setid = !uid_eq(new->euid, old->uid) || !gid_eq(new->egid, old->gid);
+        is_setid = __is_setuid(new, old) || __is_setgid(new, old);
-        if ((is_setid ||
+        if ((is_setid || __cap_gained(permitted, new, old)) &&
-             !cap_issubset(new->cap_permitted, old->cap_permitted)) &&
            ((bprm->unsafe & ~LSM_UNSAFE_PTRACE) ||
             !ptracer_capable(current, new->user_ns))) {
                /* downgrade; they get no more than they had, and maybe less */
@@ -779,7 +857,7 @@ skip:
        new->sgid = new->fsgid = new->egid;
        /* File caps or setid cancels ambient. */
-        if (has_cap || is_setid)
+        if (has_fcap || is_setid)
                cap_clear(new->cap_ambient);
        /*
@@ -800,26 +878,10 @@ skip:
        if (WARN_ON(!cap_ambient_invariant_ok(new)))
                return -EPERM;
-        /*
+        if (nonroot_raised_pE(new, old, root_uid, has_fcap)) {
-         * Audit candidate if current->cap_effective is set
+                ret = audit_log_bprm_fcaps(bprm, new, old);
-         *
+                if (ret < 0)
-         * We do not bother to audit if 3 things are true:
+                        return ret;
-         *   1) cap_effective has all caps
-         *   2) we are root
-         *   3) root is supposed to have all caps (SECURE_NOROOT)
-         * Since this is just a normal root execing a process.
-         *
-         * Number 1 above might fail if you don't have a full bset, but I think
-         * that is interesting information to audit.
-         */
-        if (!cap_issubset(new->cap_effective, new->cap_ambient)) {
-                if (!cap_issubset(CAP_FULL_SET, new->cap_effective) ||
-                    !uid_eq(new->euid, root_uid) || !uid_eq(new->uid, root_uid) ||
-                    issecure(SECURE_NOROOT)) {
-                        ret = audit_log_bprm_fcaps(bprm, new, old);
-                        if (ret < 0)
-                                return ret;
-                }
        }
        new->securebits &= ~issecure_mask(SECURE_KEEP_CAPS);
@@ -829,13 +891,11 @@ skip:
        /* Check for privilege-elevated exec. */
        bprm->cap_elevated = 0;
-        if (is_setid) {
+        if (is_setid ||
+            (!__is_real(root_uid, new) &&
+             (effective ||
+              __cap_grew(permitted, ambient, new))))
                bprm->cap_elevated = 1;
-        } else if (!uid_eq(new->uid, root_uid)) {
-                if (effective ||
-                    !cap_issubset(new->cap_permitted, new->cap_ambient))
-                        bprm->cap_elevated = 1;
-        }
        return 0;
 }
diff --git a/security/device_cgroup.c b/security/device_cgroup.c
index 5ef7e5240563..c65b39bafdfe 100644
--- a/security/device_cgroup.c
+++ b/security/device_cgroup.c
@@ -15,15 +15,6 @@
 #include <linux/rcupdate.h>
 #include <linux/mutex.h>
-#define ACC_MKNOD 1
-#define ACC_READ  2
-#define ACC_WRITE 4
-#define ACC_MASK (ACC_MKNOD | ACC_READ | ACC_WRITE)
-#define DEV_BLOCK 1
-#define DEV_CHAR  2
-#define DEV_ALL   4  /* this represents all devices */
 static DEFINE_MUTEX(devcgroup_mutex);
 enum devcg_behavior {
@@ -246,21 +237,21 @@ static void set_access(char *acc, short access)
 {
        int idx = 0;
        memset(acc, 0, ACCLEN);
-        if (access & ACC_READ)
+        if (access & DEVCG_ACC_READ)
                acc[idx++] = 'r';
-        if (access & ACC_WRITE)
+        if (access & DEVCG_ACC_WRITE)
                acc[idx++] = 'w';
-        if (access & ACC_MKNOD)
+        if (access & DEVCG_ACC_MKNOD)
                acc[idx++] = 'm';
 }
 static char type_to_char(short type)
 {
-        if (type == DEV_ALL)
+        if (type == DEVCG_DEV_ALL)
                return 'a';
-        if (type == DEV_CHAR)
+        if (type == DEVCG_DEV_CHAR)
                return 'c';
-        if (type == DEV_BLOCK)
+        if (type == DEVCG_DEV_BLOCK)
                return 'b';
        return 'X';
 }
@@ -287,10 +278,10 @@ static int devcgroup_seq_show(struct seq_file *m, void *v)
         * This way, the file remains as a "whitelist of devices"
         */
        if (devcgroup->behavior == DEVCG_DEFAULT_ALLOW) {
-                set_access(acc, ACC_MASK);
+                set_access(acc, DEVCG_ACC_MASK);
                set_majmin(maj, ~0);
                set_majmin(min, ~0);
-                seq_printf(m, "%c %s:%s %s\n", type_to_char(DEV_ALL),
+                seq_printf(m, "%c %s:%s %s\n", type_to_char(DEVCG_DEV_ALL),
                           maj, min, acc);
        } else {
                list_for_each_entry_rcu(ex, &devcgroup->exceptions, list) {
@@ -309,10 +300,10 @@ static int devcgroup_seq_show(struct seq_file *m, void *v)
 /**
 * match_exception      - iterates the exception list trying to find a complete match
 * @exceptions: list of exceptions
- * @type: device type (DEV_BLOCK or DEV_CHAR)
+ * @type: device type (DEVCG_DEV_BLOCK or DEVCG_DEV_CHAR)
 * @major: device file major number, ~0 to match all
 * @minor: device file minor number, ~0 to match all
- * @access: permission mask (ACC_READ, ACC_WRITE, ACC_MKNOD)
+ * @access: permission mask (DEVCG_ACC_READ, DEVCG_ACC_WRITE, DEVCG_ACC_MKNOD)
 *
 * It is considered a complete match if an exception is found that will
 * contain the entire range of provided parameters.
@@ -325,9 +316,9 @@ static bool match_exception(struct list_head *exceptions, short type,
        struct dev_exception_item *ex;
        list_for_each_entry_rcu(ex, exceptions, list) {
-                if ((type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
+                if ((type & DEVCG_DEV_BLOCK) && !(ex->type & DEVCG_DEV_BLOCK))
                        continue;
-                if ((type & DEV_CHAR) && !(ex->type & DEV_CHAR))
+                if ((type & DEVCG_DEV_CHAR) && !(ex->type & DEVCG_DEV_CHAR))
                        continue;
                if (ex->major != ~0 && ex->major != major)
                        continue;
@@ -344,10 +335,10 @@ static bool match_exception(struct list_head *exceptions, short type,
 /**
 * match_exception_partial - iterates the exception list trying to find a partial match
 * @exceptions: list of exceptions
- * @type: device type (DEV_BLOCK or DEV_CHAR)
+ * @type: device type (DEVCG_DEV_BLOCK or DEVCG_DEV_CHAR)
 * @major: device file major number, ~0 to match all
 * @minor: device file minor number, ~0 to match all
- * @access: permission mask (ACC_READ, ACC_WRITE, ACC_MKNOD)
+ * @access: permission mask (DEVCG_ACC_READ, DEVCG_ACC_WRITE, DEVCG_ACC_MKNOD)
 *
 * It is considered a partial match if an exception's range is found to
 * contain *any* of the devices specified by provided parameters. This is
@@ -362,9 +353,9 @@ static bool match_exception_partial(struct list_head *exceptions, short type,
        struct dev_exception_item *ex;
        list_for_each_entry_rcu(ex, exceptions, list) {
-                if ((type & DEV_BLOCK) && !(ex->type & DEV_BLOCK))
+                if ((type & DEVCG_DEV_BLOCK) && !(ex->type & DEVCG_DEV_BLOCK))
                        continue;
-                if ((type & DEV_CHAR) && !(ex->type & DEV_CHAR))
+                if ((type & DEVCG_DEV_CHAR) && !(ex->type & DEVCG_DEV_CHAR))
                        continue;
                /*
                 * We must be sure that both the exception and the provided
@@ -647,10 +638,10 @@ static int devcgroup_update_access(struct dev_cgroup *devcgroup,
                }
                return 0;
        case 'b':
-                ex.type = DEV_BLOCK;
+                ex.type = DEVCG_DEV_BLOCK;
                break;
        case 'c':
-                ex.type = DEV_CHAR;
+                ex.type = DEVCG_DEV_CHAR;
                break;
        default:
                return -EINVAL;
@@ -703,13 +694,13 @@ static int devcgroup_update_access(struct dev_cgroup *devcgroup,
        for (b++, count = 0; count < 3; count++, b++) {
                switch (*b) {
                case 'r':
-                        ex.access |= ACC_READ;
+                        ex.access |= DEVCG_ACC_READ;
                        break;
                case 'w':
-                        ex.access |= ACC_WRITE;
+                        ex.access |= DEVCG_ACC_WRITE;
                        break;
                case 'm':
-                        ex.access |= ACC_MKNOD;
+                        ex.access |= DEVCG_ACC_MKNOD;
                        break;
                case '\n':
                case '\0':
@@ -806,12 +797,12 @@ struct cgroup_subsys devices_cgrp_subsys = {
 * @type: device type
 * @major: device major number
 * @minor: device minor number
- * @access: combination of ACC_WRITE, ACC_READ and ACC_MKNOD
+ * @access: combination of DEVCG_ACC_WRITE, DEVCG_ACC_READ and DEVCG_ACC_MKNOD
 *
 * returns 0 on success, -EPERM case the operation is not permitted
 */
-static int __devcgroup_check_permission(short type, u32 major, u32 minor,
+int __devcgroup_check_permission(short type, u32 major, u32 minor,
-                                        short access)
+                                 short access)
 {
        struct dev_cgroup *dev_cgroup;
        bool rc;
@@ -833,37 +824,3 @@ static int __devcgroup_check_permission(short type, u32 major, u32 minor,
        return 0;
 }
-int __devcgroup_inode_permission(struct inode *inode, int mask)
-{
-        short type, access = 0;
-        if (S_ISBLK(inode->i_mode))
-                type = DEV_BLOCK;
-        if (S_ISCHR(inode->i_mode))
-                type = DEV_CHAR;
-        if (mask & MAY_WRITE)
-                access |= ACC_WRITE;
-        if (mask & MAY_READ)
-                access |= ACC_READ;
-        return __devcgroup_check_permission(type, imajor(inode), iminor(inode),
-                        access);
-}
-int devcgroup_inode_mknod(int mode, dev_t dev)
-{
-        short type;
-        if (!S_ISBLK(mode) && !S_ISCHR(mode))
-                return 0;
-        if (S_ISBLK(mode))
-                type = DEV_BLOCK;
-        else
-                type = DEV_CHAR;
-        return __devcgroup_check_permission(type, MAJOR(dev), MINOR(dev),
-                        ACC_MKNOD);
-}
diff --git a/security/integrity/digsig.c b/security/integrity/digsig.c
index 06554c448dce..6f9e4ce568cd 100644
--- a/security/integrity/digsig.c
+++ b/security/integrity/digsig.c
@@ -112,21 +112,25 @@ int __init integrity_init_keyring(const unsigned int id)
 int __init integrity_load_x509(const unsigned int id, const char *path)
 {
        key_ref_t key;
-        char *data;
+        void *data;
+        loff_t size;
        int rc;
        if (!keyring[id])
                return -EINVAL;
-        rc = integrity_read_file(path, &data);
+        rc = kernel_read_file_from_path(path, &data, &size, 0,
-        if (rc < 0)
+                                        READING_X509_CERTIFICATE);
+        if (rc < 0) {
+                pr_err("Unable to open file: %s (%d)", path, rc);
                return rc;
+        }
        key = key_create_or_update(make_key_ref(keyring[id], 1),
                                   "asymmetric",
                                   NULL,
                                   data,
-                                   rc,
+                                   size,
                                   ((KEY_POS_ALL & ~KEY_POS_SETATTR) |
                                    KEY_USR_VIEW | KEY_USR_READ),
                                   KEY_ALLOC_NOT_IN_QUOTA);
@@ -139,6 +143,6 @@ int __init integrity_load_x509(const unsigned int id, const char *path)
                          key_ref_to_ptr(key)->description, path);
                key_ref_put(key);
        }
-        kfree(data);
+        vfree(data);
        return 0;
 }
diff --git a/security/integrity/evm/evm.h b/security/integrity/evm/evm.h
index f5f12727771a..241aca315b0c 100644
--- a/security/integrity/evm/evm.h
+++ b/security/integrity/evm/evm.h
@@ -23,6 +23,9 @@
 #define EVM_INIT_HMAC   0x0001
 #define EVM_INIT_X509   0x0002
+#define EVM_SETUP       0x80000000 /* userland has signaled key load */
+#define EVM_INIT_MASK (EVM_INIT_HMAC | EVM_INIT_X509 | EVM_SETUP)
 extern int evm_initialized;
 extern char *evm_hmac;
diff --git a/security/integrity/evm/evm_crypto.c b/security/integrity/evm/evm_crypto.c
index 1d32cd20009a..bcd64baf8788 100644
--- a/security/integrity/evm/evm_crypto.c
+++ b/security/integrity/evm/evm_crypto.c
@@ -80,7 +80,7 @@ static struct shash_desc *init_desc(char type)
        if (type == EVM_XATTR_HMAC) {
                if (!(evm_initialized & EVM_INIT_HMAC)) {
-                        pr_err("HMAC key is not set\n");
+                        pr_err_once("HMAC key is not set\n");
                        return ERR_PTR(-ENOKEY);
                }
                tfm = &hmac_tfm;
diff --git a/security/integrity/evm/evm_main.c b/security/integrity/evm/evm_main.c
index 063d38aef64e..9826c02e2db8 100644
--- a/security/integrity/evm/evm_main.c
+++ b/security/integrity/evm/evm_main.c
@@ -49,6 +49,9 @@ char *evm_config_xattrnames[] = {
        XATTR_NAME_SMACKMMAP,
 #endif
 #endif
+#ifdef CONFIG_SECURITY_APPARMOR
+        XATTR_NAME_APPARMOR,
+#endif
 #ifdef CONFIG_IMA_APPRAISE
        XATTR_NAME_IMA,
 #endif
diff --git a/security/integrity/evm/evm_secfs.c b/security/integrity/evm/evm_secfs.c
index c8dccd54d501..319cf16d6603 100644
--- a/security/integrity/evm/evm_secfs.c
+++ b/security/integrity/evm/evm_secfs.c
@@ -40,7 +40,7 @@ static ssize_t evm_read_key(struct file *filp, char __user *buf,
        if (*ppos != 0)
                return 0;
-        sprintf(temp, "%d", evm_initialized);
+        sprintf(temp, "%d", (evm_initialized & ~EVM_SETUP));
        rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
        return rc;
@@ -61,24 +61,29 @@ static ssize_t evm_read_key(struct file *filp, char __user *buf,
 static ssize_t evm_write_key(struct file *file, const char __user *buf,
                             size_t count, loff_t *ppos)
 {
-        char temp[80];
+        int i, ret;
-        int i;
-        if (!capable(CAP_SYS_ADMIN) || (evm_initialized & EVM_INIT_HMAC))
+        if (!capable(CAP_SYS_ADMIN) || (evm_initialized & EVM_SETUP))
                return -EPERM;
-        if (count >= sizeof(temp) || count == 0)
+        ret = kstrtoint_from_user(buf, count, 0, &i);
-                return -EINVAL;
-        if (copy_from_user(temp, buf, count) != 0)
-                return -EFAULT;
-        temp[count] = '\0';
+        if (ret)
+                return ret;
-        if ((sscanf(temp, "%d", &i) != 1) || (i != 1))
+        /* Reject invalid values */
+        if (!i || (i & ~EVM_INIT_MASK) != 0)
                return -EINVAL;
-        evm_init_key();
+        if (i & EVM_INIT_HMAC) {
+                ret = evm_init_key();
+                if (ret != 0)
+                        return ret;
+                /* Forbid further writes after the symmetric key is loaded */
+                i |= EVM_SETUP;
+        }
+        evm_initialized |= i;
        return count;
 }
diff --git a/security/integrity/iint.c b/security/integrity/iint.c
index 6fc888ca468e..c84e05866052 100644
--- a/security/integrity/iint.c
+++ b/security/integrity/iint.c
@@ -200,55 +200,6 @@ int integrity_kernel_read(struct file *file, loff_t offset,
 }
 /*
- * integrity_read_file - read entire file content into the buffer
- *
- * This is function opens a file, allocates the buffer of required
- * size, read entire file content to the buffer and closes the file
- *
- * It is used only by init code.
- *
- */
-int __init integrity_read_file(const char *path, char **data)
-{
-        struct file *file;
-        loff_t size;
-        char *buf;
-        int rc = -EINVAL;
-        if (!path || !*path)
-                return -EINVAL;
-        file = filp_open(path, O_RDONLY, 0);
-        if (IS_ERR(file)) {
-                rc = PTR_ERR(file);
-                pr_err("Unable to open file: %s (%d)", path, rc);
-                return rc;
-        }
-        size = i_size_read(file_inode(file));
-        if (size <= 0)
-                goto out;
-        buf = kmalloc(size, GFP_KERNEL);
-        if (!buf) {
-                rc = -ENOMEM;
-                goto out;
-        }
-        rc = integrity_kernel_read(file, 0, buf, size);
-        if (rc == size) {
-                *data = buf;
-        } else {
-                kfree(buf);
-                if (rc >= 0)
-                        rc = -EIO;
-        }
-out:
-        fput(file);
-        return rc;
-}
-/*
 * integrity_load_keys - load integrity keys hook
 *
 * Hooks is called from init/main.c:kernel_init_freeable()
diff --git a/security/integrity/ima/ima_api.c b/security/integrity/ima/ima_api.c
index c2edba8de35e..c7e8db0ea4c0 100644
--- a/security/integrity/ima/ima_api.c
+++ b/security/integrity/ima/ima_api.c
@@ -199,42 +199,59 @@ int ima_collect_measurement(struct integrity_iint_cache *iint,
        struct inode *inode = file_inode(file);
        const char *filename = file->f_path.dentry->d_name.name;
        int result = 0;
+        int length;
+        void *tmpbuf;
+        u64 i_version;
        struct {
                struct ima_digest_data hdr;
                char digest[IMA_MAX_DIGEST_SIZE];
        } hash;
-        if (!(iint->flags & IMA_COLLECTED)) {
+        if (iint->flags & IMA_COLLECTED)
-                u64 i_version = file_inode(file)->i_version;
+                goto out;
-                if (file->f_flags & O_DIRECT) {
+        /*
-                        audit_cause = "failed(directio)";
+         * Dectecting file change is based on i_version. On filesystems
-                        result = -EACCES;
+         * which do not support i_version, support is limited to an initial
-                        goto out;
+         * measurement/appraisal/audit.
-                }
+         */
+        i_version = file_inode(file)->i_version;
+        hash.hdr.algo = algo;
-                hash.hdr.algo = algo;
+        /* Initialize hash digest to 0's in case of failure */
+        memset(&hash.digest, 0, sizeof(hash.digest));
-                result = (!buf) ?  ima_calc_file_hash(file, &hash.hdr) :
-                        ima_calc_buffer_hash(buf, size, &hash.hdr);
+        if (buf)
-                if (!result) {
+                result = ima_calc_buffer_hash(buf, size, &hash.hdr);
-                        int length = sizeof(hash.hdr) + hash.hdr.length;
+        else
-                        void *tmpbuf = krealloc(iint->ima_hash, length,
+                result = ima_calc_file_hash(file, &hash.hdr);
-                                                GFP_NOFS);
-                        if (tmpbuf) {
+        if (result && result != -EBADF && result != -EINVAL)
-                                iint->ima_hash = tmpbuf;
+                goto out;
-                                memcpy(iint->ima_hash, &hash, length);
-                                iint->version = i_version;
+        length = sizeof(hash.hdr) + hash.hdr.length;
-                                iint->flags |= IMA_COLLECTED;
+        tmpbuf = krealloc(iint->ima_hash, length, GFP_NOFS);
-                        } else
+        if (!tmpbuf) {
-                                result = -ENOMEM;
+                result = -ENOMEM;
-                }
+                goto out;
        }
+        iint->ima_hash = tmpbuf;
+        memcpy(iint->ima_hash, &hash, length);
+        iint->version = i_version;
+        /* Possibly temporary failure due to type of read (eg. O_DIRECT) */
+        if (!result)
+                iint->flags |= IMA_COLLECTED;
 out:
-        if (result)
+        if (result) {
+                if (file->f_flags & O_DIRECT)
+                        audit_cause = "failed(directio)";
                integrity_audit_msg(AUDIT_INTEGRITY_DATA, inode,
                                    filename, "collect_data", audit_cause,
                                    result, 0);
+        }
        return result;
 }
@@ -278,7 +295,7 @@ void ima_store_measurement(struct integrity_iint_cache *iint,
        }
        result = ima_store_template(entry, violation, inode, filename, pcr);
-        if (!result || result == -EEXIST) {
+        if ((!result || result == -EEXIST) && !(file->f_flags & O_DIRECT)) {
                iint->flags |= IMA_MEASURED;
                iint->measured_pcrs |= (0x1 << pcr);
        }
diff --git a/security/integrity/ima/ima_appraise.c b/security/integrity/ima/ima_appraise.c
index 809ba70fbbbf..65fbcf3c32c7 100644
--- a/security/integrity/ima/ima_appraise.c
+++ b/security/integrity/ima/ima_appraise.c
@@ -40,7 +40,7 @@ __setup("ima_appraise=", default_appraise_setup);
 */
 bool is_ima_appraise_enabled(void)
 {
-        return (ima_appraise & IMA_APPRAISE_ENFORCE) ? 1 : 0;
+        return ima_appraise & IMA_APPRAISE_ENFORCE;
 }
 /*
@@ -320,6 +320,9 @@ void ima_update_xattr(struct integrity_iint_cache *iint, struct file *file)
        if (iint->flags & IMA_DIGSIG)
                return;
+        if (iint->ima_file_status != INTEGRITY_PASS)
+                return;
        rc = ima_collect_measurement(iint, file, NULL, 0, ima_hash_algo);
        if (rc < 0)
                return;
@@ -405,7 +408,7 @@ int ima_inode_setxattr(struct dentry *dentry, const char *xattr_name,
                if (!xattr_value_len || (xvalue->type >= IMA_XATTR_LAST))
                        return -EINVAL;
                ima_reset_appraise_flags(d_backing_inode(dentry),
-                         (xvalue->type == EVM_IMA_XATTR_DIGSIG) ? 1 : 0);
+                        xvalue->type == EVM_IMA_XATTR_DIGSIG);
                result = 0;
        }
        return result;
diff --git a/security/integrity/ima/ima_crypto.c b/security/integrity/ima/ima_crypto.c
index 802d5d20f36f..9057b163c378 100644
--- a/security/integrity/ima/ima_crypto.c
+++ b/security/integrity/ima/ima_crypto.c
@@ -27,11 +27,6 @@
 #include "ima.h"
-struct ahash_completion {
-        struct completion completion;
-        int err;
-};
 /* minimum file size for ahash use */
 static unsigned long ima_ahash_minsize;
 module_param_named(ahash_minsize, ima_ahash_minsize, ulong, 0644);
@@ -196,30 +191,13 @@ static void ima_free_atfm(struct crypto_ahash *tfm)
                crypto_free_ahash(tfm);
 }
-static void ahash_complete(struct crypto_async_request *req, int err)
+static inline int ahash_wait(int err, struct crypto_wait *wait)
 {
-        struct ahash_completion *res = req->data;
-        if (err == -EINPROGRESS)
+        err = crypto_wait_req(err, wait);
-                return;
-        res->err = err;
-        complete(&res->completion);
-}
-static int ahash_wait(int err, struct ahash_completion *res)
+        if (err)
-{
-        switch (err) {
-        case 0:
-                break;
-        case -EINPROGRESS:
-        case -EBUSY:
-                wait_for_completion(&res->completion);
-                reinit_completion(&res->completion);
-                err = res->err;
-                /* fall through */
-        default:
                pr_crit_ratelimited("ahash calculation failed: err: %d\n", err);
-        }
        return err;
 }
@@ -233,7 +211,7 @@ static int ima_calc_file_hash_atfm(struct file *file,
        int rc, read = 0, rbuf_len, active = 0, ahash_rc = 0;
        struct ahash_request *req;
        struct scatterlist sg[1];
-        struct ahash_completion res;
+        struct crypto_wait wait;
        size_t rbuf_size[2];
        hash->length = crypto_ahash_digestsize(tfm);
@@ -242,12 +220,12 @@ static int ima_calc_file_hash_atfm(struct file *file,
        if (!req)
                return -ENOMEM;
-        init_completion(&res.completion);
+        crypto_init_wait(&wait);
        ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG |
                                   CRYPTO_TFM_REQ_MAY_SLEEP,
-                                   ahash_complete, &res);
+                                   crypto_req_done, &wait);
-        rc = ahash_wait(crypto_ahash_init(req), &res);
+        rc = ahash_wait(crypto_ahash_init(req), &wait);
        if (rc)
                goto out1;
@@ -288,7 +266,7 @@ static int ima_calc_file_hash_atfm(struct file *file,
                         * read/request, wait for the completion of the
                         * previous ahash_update() request.
                         */
-                        rc = ahash_wait(ahash_rc, &res);
+                        rc = ahash_wait(ahash_rc, &wait);
                        if (rc)
                                goto out3;
                }
@@ -304,7 +282,7 @@ static int ima_calc_file_hash_atfm(struct file *file,
                         * read/request, wait for the completion of the
                         * previous ahash_update() request.
                         */
-                        rc = ahash_wait(ahash_rc, &res);
+                        rc = ahash_wait(ahash_rc, &wait);
                        if (rc)
                                goto out3;
                }
@@ -318,7 +296,7 @@ static int ima_calc_file_hash_atfm(struct file *file,
                        active = !active; /* swap buffers, if we use two */
        }
        /* wait for the last update request to complete */
-        rc = ahash_wait(ahash_rc, &res);
+        rc = ahash_wait(ahash_rc, &wait);
 out3:
        if (read)
                file->f_mode &= ~FMODE_READ;
@@ -327,7 +305,7 @@ out3:
 out2:
        if (!rc) {
                ahash_request_set_crypt(req, NULL, hash->digest, 0);
-                rc = ahash_wait(crypto_ahash_final(req), &res);
+                rc = ahash_wait(crypto_ahash_final(req), &wait);
        }
 out1:
        ahash_request_free(req);
@@ -441,6 +419,16 @@ int ima_calc_file_hash(struct file *file, struct ima_digest_data *hash)
        loff_t i_size;
        int rc;
+        /*
+         * For consistency, fail file's opened with the O_DIRECT flag on
+         * filesystems mounted with/without DAX option.
+         */
+        if (file->f_flags & O_DIRECT) {
+                hash->length = hash_digest_size[ima_hash_algo];
+                hash->algo = ima_hash_algo;
+                return -EINVAL;
+        }
        i_size = i_size_read(file_inode(file));
        if (ima_ahash_minsize && i_size >= ima_ahash_minsize) {
@@ -527,7 +515,7 @@ static int calc_buffer_ahash_atfm(const void *buf, loff_t len,
 {
        struct ahash_request *req;
        struct scatterlist sg;
-        struct ahash_completion res;
+        struct crypto_wait wait;
        int rc, ahash_rc = 0;
        hash->length = crypto_ahash_digestsize(tfm);
@@ -536,12 +524,12 @@ static int calc_buffer_ahash_atfm(const void *buf, loff_t len,
        if (!req)
                return -ENOMEM;
-        init_completion(&res.completion);
+        crypto_init_wait(&wait);
        ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG |
                                   CRYPTO_TFM_REQ_MAY_SLEEP,
-                                   ahash_complete, &res);
+                                   crypto_req_done, &wait);
-        rc = ahash_wait(crypto_ahash_init(req), &res);
+        rc = ahash_wait(crypto_ahash_init(req), &wait);
        if (rc)
                goto out;
@@ -551,10 +539,10 @@ static int calc_buffer_ahash_atfm(const void *buf, loff_t len,
        ahash_rc = crypto_ahash_update(req);
        /* wait for the update request to complete */
-        rc = ahash_wait(ahash_rc, &res);
+        rc = ahash_wait(ahash_rc, &wait);
        if (!rc) {
                ahash_request_set_crypt(req, NULL, hash->digest, 0);
-                rc = ahash_wait(crypto_ahash_final(req), &res);
+                rc = ahash_wait(crypto_ahash_final(req), &wait);
        }
 out:
        ahash_request_free(req);
diff --git a/security/integrity/ima/ima_fs.c b/security/integrity/ima/ima_fs.c
index ad491c51e833..fa540c0469da 100644
--- a/security/integrity/ima/ima_fs.c
+++ b/security/integrity/ima/ima_fs.c
@@ -32,7 +32,7 @@ bool ima_canonical_fmt;
 static int __init default_canonical_fmt_setup(char *str)
 {
 #ifdef __BIG_ENDIAN
-        ima_canonical_fmt = 1;
+        ima_canonical_fmt = true;
 #endif
        return 1;
 }
@@ -429,10 +429,10 @@ static int ima_release_policy(struct inode *inode, struct file *file)
        }
        ima_update_policy();
-#ifndef CONFIG_IMA_WRITE_POLICY
+#if !defined(CONFIG_IMA_WRITE_POLICY) && !defined(CONFIG_IMA_READ_POLICY)
        securityfs_remove(ima_policy);
        ima_policy = NULL;
-#else
+#elif defined(CONFIG_IMA_WRITE_POLICY)
        clear_bit(IMA_FS_BUSY, &ima_fs_flags);
 #endif
        return 0;
diff --git a/security/integrity/ima/ima_main.c b/security/integrity/ima/ima_main.c
index 2aebb7984437..770654694efc 100644
--- a/security/integrity/ima/ima_main.c
+++ b/security/integrity/ima/ima_main.c
@@ -51,6 +51,8 @@ static int __init hash_setup(char *str)
                        ima_hash_algo = HASH_ALGO_SHA1;
                else if (strncmp(str, "md5", 3) == 0)
                        ima_hash_algo = HASH_ALGO_MD5;
+                else
+                        return 1;
                goto out;
        }
@@ -60,6 +62,8 @@ static int __init hash_setup(char *str)
                        break;
                }
        }
+        if (i == HASH_ALGO__LAST)
+                return 1;
 out:
        hash_setup_done = 1;
        return 1;
@@ -235,11 +239,8 @@ static int process_measurement(struct file *file, char *buf, loff_t size,
        hash_algo = ima_get_hash_algo(xattr_value, xattr_len);
        rc = ima_collect_measurement(iint, file, buf, size, hash_algo);
-        if (rc != 0) {
+        if (rc != 0 && rc != -EBADF && rc != -EINVAL)
-                if (file->f_flags & O_DIRECT)
-                        rc = (iint->flags & IMA_PERMIT_DIRECTIO) ? 0 : -EACCES;
                goto out_digsig;
-        }
        if (!pathbuf)   /* ima_rdwr_violation possibly pre-fetched */
                pathname = ima_d_path(&file->f_path, &pathbuf, filename);
@@ -247,12 +248,14 @@ static int process_measurement(struct file *file, char *buf, loff_t size,
        if (action & IMA_MEASURE)
                ima_store_measurement(iint, file, pathname,
                                      xattr_value, xattr_len, pcr);
-        if (action & IMA_APPRAISE_SUBMASK)
+        if (rc == 0 && (action & IMA_APPRAISE_SUBMASK))
                rc = ima_appraise_measurement(func, iint, file, pathname,
                                              xattr_value, xattr_len, opened);
        if (action & IMA_AUDIT)
                ima_audit_measurement(iint, pathname);
+        if ((file->f_flags & O_DIRECT) && (iint->flags & IMA_PERMIT_DIRECTIO))
+                rc = 0;
 out_digsig:
        if ((mask & MAY_WRITE) && (iint->flags & IMA_DIGSIG) &&
             !(iint->flags & IMA_NEW_FILE))
@@ -359,12 +362,12 @@ void ima_post_path_mknod(struct dentry *dentry)
 */
 int ima_read_file(struct file *file, enum kernel_read_file_id read_id)
 {
+        bool sig_enforce = is_module_sig_enforced();
        if (!file && read_id == READING_MODULE) {
-#ifndef CONFIG_MODULE_SIG_FORCE
+                if (!sig_enforce && (ima_appraise & IMA_APPRAISE_MODULES) &&
-                if ((ima_appraise & IMA_APPRAISE_MODULES) &&
                    (ima_appraise & IMA_APPRAISE_ENFORCE))
                        return -EACCES; /* INTEGRITY_UNKNOWN */
-#endif
                return 0;       /* We rely on module signature checking */
        }
        return 0;
@@ -406,6 +409,10 @@ int ima_post_read_file(struct file *file, void *buf, loff_t size,
        if (!file && read_id == READING_MODULE) /* MODULE_SIG_FORCE enabled */
                return 0;
+        /* permit signed certs */
+        if (!file && read_id == READING_X509_CERTIFICATE)
+                return 0;
        if (!file || !buf || size == 0) { /* should never happen */
                if (ima_appraise & IMA_APPRAISE_ENFORCE)
                        return -EACCES;
diff --git a/security/integrity/ima/ima_policy.c b/security/integrity/ima/ima_policy.c
index 95209a5f8595..ee4613fa5840 100644
--- a/security/integrity/ima/ima_policy.c
+++ b/security/integrity/ima/ima_policy.c
@@ -196,9 +196,9 @@ static int __init policy_setup(char *str)
                if ((strcmp(p, "tcb") == 0) && !ima_policy)
                        ima_policy = DEFAULT_TCB;
                else if (strcmp(p, "appraise_tcb") == 0)
-                        ima_use_appraise_tcb = 1;
+                        ima_use_appraise_tcb = true;
                else if (strcmp(p, "secure_boot") == 0)
-                        ima_use_secure_boot = 1;
+                        ima_use_secure_boot = true;
        }
        return 1;
@@ -207,7 +207,7 @@ __setup("ima_policy=", policy_setup);
 static int __init default_appraise_policy_setup(char *str)
 {
-        ima_use_appraise_tcb = 1;
+        ima_use_appraise_tcb = true;
        return 1;
 }
 __setup("ima_appraise_tcb", default_appraise_policy_setup);
diff --git a/security/integrity/integrity.h b/security/integrity/integrity.h
index a53e7e4ab06c..e1bf040fb110 100644
--- a/security/integrity/integrity.h
+++ b/security/integrity/integrity.h
@@ -120,8 +120,6 @@ struct integrity_iint_cache *integrity_iint_find(struct inode *inode);
 int integrity_kernel_read(struct file *file, loff_t offset,
                          void *addr, unsigned long count);
-int __init integrity_read_file(const char *path, char **data);
 #define INTEGRITY_KEYRING_EVM           0
 #define INTEGRITY_KEYRING_IMA           1
 #define INTEGRITY_KEYRING_MODULE        2
diff --git a/security/keys/gc.c b/security/keys/gc.c
index f01d48cb3de1..7207e6094dc1 100644
--- a/security/keys/gc.c
+++ b/security/keys/gc.c
@@ -29,10 +29,10 @@ DECLARE_WORK(key_gc_work, key_garbage_collector);
 /*
 * Reaper for links from keyrings to dead keys.
 */
-static void key_gc_timer_func(unsigned long);
+static void key_gc_timer_func(struct timer_list *);
-static DEFINE_TIMER(key_gc_timer, key_gc_timer_func, 0, 0);
+static DEFINE_TIMER(key_gc_timer, key_gc_timer_func);
-static time_t key_gc_next_run = LONG_MAX;
+static time64_t key_gc_next_run = TIME64_MAX;
 static struct key_type *key_gc_dead_keytype;
 static unsigned long key_gc_flags;
@@ -53,12 +53,12 @@ struct key_type key_type_dead = {
 * Schedule a garbage collection run.
 * - time precision isn't particularly important
 */
-void key_schedule_gc(time_t gc_at)
+void key_schedule_gc(time64_t gc_at)
 {
        unsigned long expires;
-        time_t now = current_kernel_time().tv_sec;
+        time64_t now = ktime_get_real_seconds();
-        kenter("%ld", gc_at - now);
+        kenter("%lld", gc_at - now);
        if (gc_at <= now || test_bit(KEY_GC_REAP_KEYTYPE, &key_gc_flags)) {
                kdebug("IMMEDIATE");
@@ -84,10 +84,10 @@ void key_schedule_gc_links(void)
 * Some key's cleanup time was met after it expired, so we need to get the
 * reaper to go through a cycle finding expired keys.
 */
-static void key_gc_timer_func(unsigned long data)
+static void key_gc_timer_func(struct timer_list *unused)
 {
        kenter("");
-        key_gc_next_run = LONG_MAX;
+        key_gc_next_run = TIME64_MAX;
        key_schedule_gc_links();
 }
@@ -184,11 +184,11 @@ static void key_garbage_collector(struct work_struct *work)
        struct rb_node *cursor;
        struct key *key;
-        time_t new_timer, limit;
+        time64_t new_timer, limit;
        kenter("[%lx,%x]", key_gc_flags, gc_state);
-        limit = current_kernel_time().tv_sec;
+        limit = ktime_get_real_seconds();
        if (limit > key_gc_delay)
                limit -= key_gc_delay;
        else
@@ -204,7 +204,7 @@ static void key_garbage_collector(struct work_struct *work)
                gc_state |= KEY_GC_REAPING_DEAD_1;
        kdebug("new pass %x", gc_state);
-        new_timer = LONG_MAX;
+        new_timer = TIME64_MAX;
        /* As only this function is permitted to remove things from the key
         * serial tree, if cursor is non-NULL then it will always point to a
@@ -235,7 +235,7 @@ continue_scanning:
                if (gc_state & KEY_GC_SET_TIMER) {
                        if (key->expiry > limit && key->expiry < new_timer) {
-                                kdebug("will expire %x in %ld",
+                                kdebug("will expire %x in %lld",
                                       key_serial(key), key->expiry - limit);
                                new_timer = key->expiry;
                        }
@@ -276,7 +276,7 @@ maybe_resched:
         */
        kdebug("pass complete");
-        if (gc_state & KEY_GC_SET_TIMER && new_timer != (time_t)LONG_MAX) {
+        if (gc_state & KEY_GC_SET_TIMER && new_timer != (time64_t)TIME64_MAX) {
                new_timer += key_gc_delay;
                key_schedule_gc(new_timer);
        }
diff --git a/security/keys/internal.h b/security/keys/internal.h
index 503adbae7b0d..9f8208dc0e55 100644
--- a/security/keys/internal.h
+++ b/security/keys/internal.h
@@ -130,7 +130,7 @@ struct keyring_search_context {
        int                     skipped_ret;
        bool                    possessed;
        key_ref_t               result;
-        struct timespec         now;
+        time64_t                now;
 };
 extern bool key_default_cmp(const struct key *key,
@@ -169,10 +169,10 @@ extern void key_change_session_keyring(struct callback_head *twork);
 extern struct work_struct key_gc_work;
 extern unsigned key_gc_delay;
-extern void keyring_gc(struct key *keyring, time_t limit);
+extern void keyring_gc(struct key *keyring, time64_t limit);
 extern void keyring_restriction_gc(struct key *keyring,
                                   struct key_type *dead_type);
-extern void key_schedule_gc(time_t gc_at);
+extern void key_schedule_gc(time64_t gc_at);
 extern void key_schedule_gc_links(void);
 extern void key_gc_keytype(struct key_type *ktype);
@@ -211,7 +211,7 @@ extern struct key *key_get_instantiation_authkey(key_serial_t target_id);
 /*
 * Determine whether a key is dead.
 */
-static inline bool key_is_dead(const struct key *key, time_t limit)
+static inline bool key_is_dead(const struct key *key, time64_t limit)
 {
        return
                key->flags & ((1 << KEY_FLAG_DEAD) |
diff --git a/security/keys/key.c b/security/keys/key.c
index 83bf4b4afd49..d97c9394b5dd 100644
--- a/security/keys/key.c
+++ b/security/keys/key.c
@@ -460,7 +460,7 @@ static int __key_instantiate_and_link(struct key *key,
                        if (authkey)
                                key_revoke(authkey);
-                        if (prep->expiry != TIME_T_MAX) {
+                        if (prep->expiry != TIME64_MAX) {
                                key->expiry = prep->expiry;
                                key_schedule_gc(prep->expiry + key_gc_delay);
                        }
@@ -506,7 +506,7 @@ int key_instantiate_and_link(struct key *key,
        prep.data = data;
        prep.datalen = datalen;
        prep.quotalen = key->type->def_datalen;
-        prep.expiry = TIME_T_MAX;
+        prep.expiry = TIME64_MAX;
        if (key->type->preparse) {
                ret = key->type->preparse(&prep);
                if (ret < 0)
@@ -570,7 +570,6 @@ int key_reject_and_link(struct key *key,
                        struct key *authkey)
 {
        struct assoc_array_edit *edit;
-        struct timespec now;
        int ret, awaken, link_ret = 0;
        key_check(key);
@@ -593,8 +592,7 @@ int key_reject_and_link(struct key *key,
                /* mark the key as being negatively instantiated */
                atomic_inc(&key->user->nikeys);
                mark_key_instantiated(key, -error);
-                now = current_kernel_time();
+                key->expiry = ktime_get_real_seconds() + timeout;
-                key->expiry = now.tv_sec + timeout;
                key_schedule_gc(key->expiry + key_gc_delay);
                if (test_and_clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags))
@@ -710,16 +708,13 @@ found_kernel_type:
 void key_set_timeout(struct key *key, unsigned timeout)
 {
-        struct timespec now;
+        time64_t expiry = 0;
-        time_t expiry = 0;
        /* make the changes with the locks held to prevent races */
        down_write(&key->sem);
-        if (timeout > 0) {
+        if (timeout > 0)
-                now = current_kernel_time();
+                expiry = ktime_get_real_seconds() + timeout;
-                expiry = now.tv_sec + timeout;
-        }
        key->expiry = expiry;
        key_schedule_gc(key->expiry + key_gc_delay);
@@ -838,7 +833,6 @@ key_ref_t key_create_or_update(key_ref_t keyring_ref,
        key_check(keyring);
-        key_ref = ERR_PTR(-EPERM);
        if (!(flags & KEY_ALLOC_BYPASS_RESTRICTION))
                restrict_link = keyring->restrict_link;
@@ -850,7 +844,7 @@ key_ref_t key_create_or_update(key_ref_t keyring_ref,
        prep.data = payload;
        prep.datalen = plen;
        prep.quotalen = index_key.type->def_datalen;
-        prep.expiry = TIME_T_MAX;
+        prep.expiry = TIME64_MAX;
        if (index_key.type->preparse) {
                ret = index_key.type->preparse(&prep);
                if (ret < 0) {
@@ -994,7 +988,7 @@ int key_update(key_ref_t key_ref, const void *payload, size_t plen)
        prep.data = payload;
        prep.datalen = plen;
        prep.quotalen = key->type->def_datalen;
-        prep.expiry = TIME_T_MAX;
+        prep.expiry = TIME64_MAX;
        if (key->type->preparse) {
                ret = key->type->preparse(&prep);
                if (ret < 0)
@@ -1028,8 +1022,7 @@ EXPORT_SYMBOL(key_update);
 */
 void key_revoke(struct key *key)
 {
-        struct timespec now;
+        time64_t time;
-        time_t time;
        key_check(key);
@@ -1044,8 +1037,7 @@ void key_revoke(struct key *key)
                key->type->revoke(key);
        /* set the death time to no more than the expiry time */
-        now = current_kernel_time();
+        time = ktime_get_real_seconds();
-        time = now.tv_sec;
        if (key->revoked_at == 0 || key->revoked_at > time) {
                key->revoked_at = time;
                key_schedule_gc(key->revoked_at + key_gc_delay);
diff --git a/security/keys/keyctl.c b/security/keys/keyctl.c
index 76d22f726ae4..1ffe60bb2845 100644
--- a/security/keys/keyctl.c
+++ b/security/keys/keyctl.c
@@ -1588,9 +1588,8 @@ error_keyring:
 * The caller must have Setattr permission to change keyring restrictions.
 *
 * The requested type name may be a NULL pointer to reject all attempts
- * to link to the keyring. If _type is non-NULL, _restriction can be
+ * to link to the keyring.  In this case, _restriction must also be NULL.
- * NULL or a pointer to a string describing the restriction. If _type is
+ * Otherwise, both _type and _restriction must be non-NULL.
- * NULL, _restriction must also be NULL.
 *
 * Returns 0 if successful.
 */
@@ -1598,7 +1597,6 @@ long keyctl_restrict_keyring(key_serial_t id, const char __user *_type,
                             const char __user *_restriction)
 {
        key_ref_t key_ref;
-        bool link_reject = !_type;
        char type[32];
        char *restriction = NULL;
        long ret;
@@ -1607,31 +1605,29 @@ long keyctl_restrict_keyring(key_serial_t id, const char __user *_type,
        if (IS_ERR(key_ref))
                return PTR_ERR(key_ref);
+        ret = -EINVAL;
        if (_type) {
-                ret = key_get_type_from_user(type, _type, sizeof(type));
+                if (!_restriction)
-                if (ret < 0)
                        goto error;
-        }
-        if (_restriction) {
+                ret = key_get_type_from_user(type, _type, sizeof(type));
-                if (!_type) {
+                if (ret < 0)
-                        ret = -EINVAL;
                        goto error;
-                }
                restriction = strndup_user(_restriction, PAGE_SIZE);
                if (IS_ERR(restriction)) {
                        ret = PTR_ERR(restriction);
                        goto error;
                }
+        } else {
+                if (_restriction)
+                        goto error;
        }
-        ret = keyring_restrict(key_ref, link_reject ? NULL : type, restriction);
+        ret = keyring_restrict(key_ref, _type ? type : NULL, restriction);
        kfree(restriction);
 error:
        key_ref_put(key_ref);
        return ret;
 }
diff --git a/security/keys/keyring.c b/security/keys/keyring.c
index 36f842ec87f0..d0bccebbd3b5 100644
--- a/security/keys/keyring.c
+++ b/security/keys/keyring.c
@@ -565,7 +565,7 @@ static int keyring_search_iterator(const void *object, void *iterator_data)
        /* skip invalidated, revoked and expired keys */
        if (ctx->flags & KEYRING_SEARCH_DO_STATE_CHECK) {
-                time_t expiry = READ_ONCE(key->expiry);
+                time64_t expiry = READ_ONCE(key->expiry);
                if (kflags & ((1 << KEY_FLAG_INVALIDATED) |
                              (1 << KEY_FLAG_REVOKED))) {
@@ -574,7 +574,7 @@ static int keyring_search_iterator(const void *object, void *iterator_data)
                        goto skipped;
                }
-                if (expiry && ctx->now.tv_sec >= expiry) {
+                if (expiry && ctx->now >= expiry) {
                        if (!(ctx->flags & KEYRING_SEARCH_SKIP_EXPIRED))
                                ctx->result = ERR_PTR(-EKEYEXPIRED);
                        kleave(" = %d [expire]", ctx->skipped_ret);
@@ -834,10 +834,10 @@ found:
        key = key_ref_to_ptr(ctx->result);
        key_check(key);
        if (!(ctx->flags & KEYRING_SEARCH_NO_UPDATE_TIME)) {
-                key->last_used_at = ctx->now.tv_sec;
+                key->last_used_at = ctx->now;
-                keyring->last_used_at = ctx->now.tv_sec;
+                keyring->last_used_at = ctx->now;
                while (sp > 0)
-                        stack[--sp].keyring->last_used_at = ctx->now.tv_sec;
+                        stack[--sp].keyring->last_used_at = ctx->now;
        }
        kleave(" = true");
        return true;
@@ -898,7 +898,7 @@ key_ref_t keyring_search_aux(key_ref_t keyring_ref,
        }
        rcu_read_lock();
-        ctx->now = current_kernel_time();
+        ctx->now = ktime_get_real_seconds();
        if (search_nested_keyrings(keyring, ctx))
                __key_get(key_ref_to_ptr(ctx->result));
        rcu_read_unlock();
@@ -1149,7 +1149,7 @@ struct key *find_keyring_by_name(const char *name, bool uid_keyring)
                         * (ie. it has a zero usage count) */
                        if (!refcount_inc_not_zero(&keyring->usage))
                                continue;
-                        keyring->last_used_at = current_kernel_time().tv_sec;
+                        keyring->last_used_at = ktime_get_real_seconds();
                        goto out;
                }
        }
@@ -1489,7 +1489,7 @@ static void keyring_revoke(struct key *keyring)
 static bool keyring_gc_select_iterator(void *object, void *iterator_data)
 {
        struct key *key = keyring_ptr_to_key(object);
-        time_t *limit = iterator_data;
+        time64_t *limit = iterator_data;
        if (key_is_dead(key, *limit))
                return false;
@@ -1500,7 +1500,7 @@ static bool keyring_gc_select_iterator(void *object, void *iterator_data)
 static int keyring_gc_check_iterator(const void *object, void *iterator_data)
 {
        const struct key *key = keyring_ptr_to_key(object);
-        time_t *limit = iterator_data;
+        time64_t *limit = iterator_data;
        key_check(key);
        return key_is_dead(key, *limit);
@@ -1512,7 +1512,7 @@ static int keyring_gc_check_iterator(const void *object, void *iterator_data)
 * Not called with any locks held.  The keyring's key struct will not be
 * deallocated under us as only our caller may deallocate it.
 */
-void keyring_gc(struct key *keyring, time_t limit)
+void keyring_gc(struct key *keyring, time64_t limit)
 {
        int result;
diff --git a/security/keys/permission.c b/security/keys/permission.c
index a72b4dd70c8a..f68dc04d614e 100644
--- a/security/keys/permission.c
+++ b/security/keys/permission.c
@@ -89,7 +89,7 @@ EXPORT_SYMBOL(key_task_permission);
 int key_validate(const struct key *key)
 {
        unsigned long flags = READ_ONCE(key->flags);
-        time_t expiry = READ_ONCE(key->expiry);
+        time64_t expiry = READ_ONCE(key->expiry);
        if (flags & (1 << KEY_FLAG_INVALIDATED))
                return -ENOKEY;
@@ -101,8 +101,7 @@ int key_validate(const struct key *key)
        /* check it hasn't expired */
        if (expiry) {
-                struct timespec now = current_kernel_time();
+                if (ktime_get_real_seconds() >= expiry)
-                if (now.tv_sec >= expiry)
                        return -EKEYEXPIRED;
        }
diff --git a/security/keys/proc.c b/security/keys/proc.c
index 6d1fcbba1e09..fbc4af5c6c9f 100644
--- a/security/keys/proc.c
+++ b/security/keys/proc.c
@@ -178,13 +178,12 @@ static int proc_keys_show(struct seq_file *m, void *v)
 {
        struct rb_node *_p = v;
        struct key *key = rb_entry(_p, struct key, serial_node);
-        struct timespec now;
-        time_t expiry;
-        unsigned long timo;
        unsigned long flags;
        key_ref_t key_ref, skey_ref;
+        time64_t now, expiry;
        char xbuf[16];
        short state;
+        u64 timo;
        int rc;
        struct keyring_search_context ctx = {
@@ -215,7 +214,7 @@ static int proc_keys_show(struct seq_file *m, void *v)
        if (rc < 0)
                return 0;
-        now = current_kernel_time();
+        now = ktime_get_real_seconds();
        rcu_read_lock();
@@ -223,21 +222,21 @@ static int proc_keys_show(struct seq_file *m, void *v)
        expiry = READ_ONCE(key->expiry);
        if (expiry == 0) {
                memcpy(xbuf, "perm", 5);
-        } else if (now.tv_sec >= expiry) {
+        } else if (now >= expiry) {
                memcpy(xbuf, "expd", 5);
        } else {
-                timo = expiry - now.tv_sec;
+                timo = expiry - now;
                if (timo < 60)
-                        sprintf(xbuf, "%lus", timo);
+                        sprintf(xbuf, "%llus", timo);
                else if (timo < 60*60)
-                        sprintf(xbuf, "%lum", timo / 60);
+                        sprintf(xbuf, "%llum", div_u64(timo, 60));
                else if (timo < 60*60*24)
-                        sprintf(xbuf, "%luh", timo / (60*60));
+                        sprintf(xbuf, "%lluh", div_u64(timo, 60 * 60));
                else if (timo < 60*60*24*7)
-                        sprintf(xbuf, "%lud", timo / (60*60*24));
+                        sprintf(xbuf, "%llud", div_u64(timo, 60 * 60 * 24));
                else
-                        sprintf(xbuf, "%luw", timo / (60*60*24*7));
+                        sprintf(xbuf, "%lluw", div_u64(timo, 60 * 60 * 24 * 7));
        }
        state = key_read_state(key);
diff --git a/security/keys/process_keys.c b/security/keys/process_keys.c
index 740affd65ee9..d5b25e535d3a 100644
--- a/security/keys/process_keys.c
+++ b/security/keys/process_keys.c
@@ -738,7 +738,7 @@ try_again:
        if (ret < 0)
                goto invalid_key;
-        key->last_used_at = current_kernel_time().tv_sec;
+        key->last_used_at = ktime_get_real_seconds();
 error:
        put_cred(ctx.cred);
diff --git a/security/keys/request_key.c b/security/keys/request_key.c
index e8036cd0ad54..114f7408feee 100644
--- a/security/keys/request_key.c
+++ b/security/keys/request_key.c
@@ -251,11 +251,12 @@ static int construct_key(struct key *key, const void *callout_info,
 * The keyring selected is returned with an extra reference upon it which the
 * caller must release.
 */
-static void construct_get_dest_keyring(struct key **_dest_keyring)
+static int construct_get_dest_keyring(struct key **_dest_keyring)
 {
        struct request_key_auth *rka;
        const struct cred *cred = current_cred();
        struct key *dest_keyring = *_dest_keyring, *authkey;
+        int ret;
        kenter("%p", dest_keyring);
@@ -264,6 +265,8 @@ static void construct_get_dest_keyring(struct key **_dest_keyring)
                /* the caller supplied one */
                key_get(dest_keyring);
        } else {
+                bool do_perm_check = true;
                /* use a default keyring; falling through the cases until we
                 * find one that we actually have */
                switch (cred->jit_keyring) {
@@ -278,8 +281,10 @@ static void construct_get_dest_keyring(struct key **_dest_keyring)
                                        dest_keyring =
                                                key_get(rka->dest_keyring);
                                up_read(&authkey->sem);
-                                if (dest_keyring)
+                                if (dest_keyring) {
+                                        do_perm_check = false;
                                        break;
+                                }
                        }
                case KEY_REQKEY_DEFL_THREAD_KEYRING:
@@ -314,11 +319,29 @@ static void construct_get_dest_keyring(struct key **_dest_keyring)
                default:
                        BUG();
                }
+                /*
+                 * Require Write permission on the keyring.  This is essential
+                 * because the default keyring may be the session keyring, and
+                 * joining a keyring only requires Search permission.
+                 *
+                 * However, this check is skipped for the "requestor keyring" so
+                 * that /sbin/request-key can itself use request_key() to add
+                 * keys to the original requestor's destination keyring.
+                 */
+                if (dest_keyring && do_perm_check) {
+                        ret = key_permission(make_key_ref(dest_keyring, 1),
+                                             KEY_NEED_WRITE);
+                        if (ret) {
+                                key_put(dest_keyring);
+                                return ret;
+                        }
+                }
        }
        *_dest_keyring = dest_keyring;
        kleave(" [dk %d]", key_serial(dest_keyring));
-        return;
+        return 0;
 }
 /*
@@ -444,11 +467,15 @@ static struct key *construct_key_and_link(struct keyring_search_context *ctx,
        if (ctx->index_key.type == &key_type_keyring)
                return ERR_PTR(-EPERM);
-        user = key_user_lookup(current_fsuid());
+        ret = construct_get_dest_keyring(&dest_keyring);
-        if (!user)
+        if (ret)
-                return ERR_PTR(-ENOMEM);
+                goto error;
-        construct_get_dest_keyring(&dest_keyring);
+        user = key_user_lookup(current_fsuid());
+        if (!user) {
+                ret = -ENOMEM;
+                goto error_put_dest_keyring;
+        }
        ret = construct_alloc_key(ctx, dest_keyring, flags, user, &key);
        key_user_put(user);
@@ -463,7 +490,7 @@ static struct key *construct_key_and_link(struct keyring_search_context *ctx,
        } else if (ret == -EINPROGRESS) {
                ret = 0;
        } else {
-                goto couldnt_alloc_key;
+                goto error_put_dest_keyring;
        }
        key_put(dest_keyring);
@@ -473,8 +500,9 @@ static struct key *construct_key_and_link(struct keyring_search_context *ctx,
 construction_failed:
        key_negate_and_link(key, key_negative_timeout, NULL, NULL);
        key_put(key);
-couldnt_alloc_key:
+error_put_dest_keyring:
        key_put(dest_keyring);
+error:
        kleave(" = %d", ret);
        return ERR_PTR(ret);
 }
@@ -546,9 +574,7 @@ struct key *request_key_and_link(struct key_type *type,
        if (!IS_ERR(key_ref)) {
                key = key_ref_to_ptr(key_ref);
                if (dest_keyring) {
-                        construct_get_dest_keyring(&dest_keyring);
                        ret = key_link(dest_keyring, key);
-                        key_put(dest_keyring);
                        if (ret < 0) {
                                key_put(key);
                                key = ERR_PTR(ret);
diff --git a/security/security.c b/security/security.c
index 4bf0f571b4ef..1cd8526cb0b7 100644
--- a/security/security.c
+++ b/security/security.c
@@ -12,6 +12,7 @@
 *      (at your option) any later version.
 */
+#include <linux/bpf.h>
 #include <linux/capability.h>
 #include <linux/dcache.h>
 #include <linux/module.h>
@@ -1703,3 +1704,34 @@ int security_audit_rule_match(u32 secid, u32 field, u32 op, void *lsmrule,
                                actx);
 }
 #endif /* CONFIG_AUDIT */
+#ifdef CONFIG_BPF_SYSCALL
+int security_bpf(int cmd, union bpf_attr *attr, unsigned int size)
+{
+        return call_int_hook(bpf, 0, cmd, attr, size);
+}
+int security_bpf_map(struct bpf_map *map, fmode_t fmode)
+{
+        return call_int_hook(bpf_map, 0, map, fmode);
+}
+int security_bpf_prog(struct bpf_prog *prog)
+{
+        return call_int_hook(bpf_prog, 0, prog);
+}
+int security_bpf_map_alloc(struct bpf_map *map)
+{
+        return call_int_hook(bpf_map_alloc_security, 0, map);
+}
+int security_bpf_prog_alloc(struct bpf_prog_aux *aux)
+{
+        return call_int_hook(bpf_prog_alloc_security, 0, aux);
+}
+void security_bpf_map_free(struct bpf_map *map)
+{
+        call_void_hook(bpf_map_free_security, map);
+}
+void security_bpf_prog_free(struct bpf_prog_aux *aux)
+{
+        call_void_hook(bpf_prog_free_security, aux);
+}
+#endif /* CONFIG_BPF_SYSCALL */
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index f5d304736852..8644d864e3c1 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -85,6 +85,7 @@
 #include <linux/export.h>
 #include <linux/msg.h>
 #include <linux/shm.h>
+#include <linux/bpf.h>
 #include "avc.h"
 #include "objsec.h"
@@ -1814,6 +1815,10 @@ static inline int file_path_has_perm(const struct cred *cred,
        return inode_has_perm(cred, file_inode(file), av, &ad);
 }
+#ifdef CONFIG_BPF_SYSCALL
+static int bpf_fd_pass(struct file *file, u32 sid);
+#endif
 /* Check whether a task can use an open file descriptor to
   access an inode in a given way.  Check access to the
   descriptor itself, and then use dentry_has_perm to
@@ -1844,6 +1849,12 @@ static int file_has_perm(const struct cred *cred,
                        goto out;
        }
+#ifdef CONFIG_BPF_SYSCALL
+        rc = bpf_fd_pass(file, cred_sid(cred));
+        if (rc)
+                return rc;
+#endif
        /* av is zero if only checking access to the descriptor. */
        rc = 0;
        if (av)
@@ -2164,6 +2175,12 @@ static int selinux_binder_transfer_file(struct task_struct *from,
                        return rc;
        }
+#ifdef CONFIG_BPF_SYSCALL
+        rc = bpf_fd_pass(file, sid);
+        if (rc)
+                return rc;
+#endif
        if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
                return 0;
@@ -2918,13 +2935,12 @@ static int selinux_inode_init_security(struct inode *inode, struct inode *dir,
 {
        const struct task_security_struct *tsec = current_security();
        struct superblock_security_struct *sbsec;
-        u32 sid, newsid, clen;
+        u32 newsid, clen;
        int rc;
        char *context;
        sbsec = dir->i_sb->s_security;
-        sid = tsec->sid;
        newsid = tsec->create_sid;
        rc = selinux_determine_inode_label(current_security(),
@@ -3124,27 +3140,6 @@ static int selinux_inode_getattr(const struct path *path)
        return path_has_perm(current_cred(), path, FILE__GETATTR);
 }
-static int selinux_inode_setotherxattr(struct dentry *dentry, const char *name)
-{
-        const struct cred *cred = current_cred();
-        if (!strncmp(name, XATTR_SECURITY_PREFIX,
-                     sizeof XATTR_SECURITY_PREFIX - 1)) {
-                if (!strcmp(name, XATTR_NAME_CAPS)) {
-                        if (!capable(CAP_SETFCAP))
-                                return -EPERM;
-                } else if (!capable(CAP_SYS_ADMIN)) {
-                        /* A different attribute in the security namespace.
-                           Restrict to administrator. */
-                        return -EPERM;
-                }
-        }
-        /* Not an attribute we recognize, so just check the
-           ordinary setattr permission. */
-        return dentry_has_perm(cred, dentry, FILE__SETATTR);
-}
 static bool has_cap_mac_admin(bool audit)
 {
        const struct cred *cred = current_cred();
@@ -3167,8 +3162,15 @@ static int selinux_inode_setxattr(struct dentry *dentry, const char *name,
        u32 newsid, sid = current_sid();
        int rc = 0;
-        if (strcmp(name, XATTR_NAME_SELINUX))
+        if (strcmp(name, XATTR_NAME_SELINUX)) {
-                return selinux_inode_setotherxattr(dentry, name);
+                rc = cap_inode_setxattr(dentry, name, value, size, flags);
+                if (rc)
+                        return rc;
+                /* Not an attribute we recognize, so just check the
+                   ordinary setattr permission. */
+                return dentry_has_perm(current_cred(), dentry, FILE__SETATTR);
+        }
        sbsec = inode->i_sb->s_security;
        if (!(sbsec->flags & SBLABEL_MNT))
@@ -3191,18 +3193,17 @@ static int selinux_inode_setxattr(struct dentry *dentry, const char *name,
                if (!has_cap_mac_admin(true)) {
                        struct audit_buffer *ab;
                        size_t audit_size;
-                        const char *str;
                        /* We strip a nul only if it is at the end, otherwise the
                         * context contains a nul and we should audit that */
                        if (value) {
-                                str = value;
+                                const char *str = value;
                                if (str[size - 1] == '\0')
                                        audit_size = size - 1;
                                else
                                        audit_size = size;
                        } else {
-                                str = "";
                                audit_size = 0;
                        }
                        ab = audit_log_start(current->audit_context, GFP_ATOMIC, AUDIT_SELINUX_ERR);
@@ -3282,8 +3283,15 @@ static int selinux_inode_listxattr(struct dentry *dentry)
 static int selinux_inode_removexattr(struct dentry *dentry, const char *name)
 {
-        if (strcmp(name, XATTR_NAME_SELINUX))
+        if (strcmp(name, XATTR_NAME_SELINUX)) {
-                return selinux_inode_setotherxattr(dentry, name);
+                int rc = cap_inode_removexattr(dentry, name);
+                if (rc)
+                        return rc;
+                /* Not an attribute we recognize, so just check the
+                   ordinary setattr permission. */
+                return dentry_has_perm(current_cred(), dentry, FILE__SETATTR);
+        }
        /* No one is allowed to remove a SELinux security label.
           You can change the label, but all data must be labeled. */
@@ -3978,8 +3986,8 @@ static int selinux_task_getioprio(struct task_struct *p)
                            PROCESS__GETSCHED, NULL);
 }
-int selinux_task_prlimit(const struct cred *cred, const struct cred *tcred,
+static int selinux_task_prlimit(const struct cred *cred, const struct cred *tcred,
-                         unsigned int flags)
+                                unsigned int flags)
 {
        u32 av = 0;
@@ -6252,6 +6260,139 @@ static void selinux_ib_free_security(void *ib_sec)
 }
 #endif
+#ifdef CONFIG_BPF_SYSCALL
+static int selinux_bpf(int cmd, union bpf_attr *attr,
+                                     unsigned int size)
+{
+        u32 sid = current_sid();
+        int ret;
+        switch (cmd) {
+        case BPF_MAP_CREATE:
+                ret = avc_has_perm(sid, sid, SECCLASS_BPF, BPF__MAP_CREATE,
+                                   NULL);
+                break;
+        case BPF_PROG_LOAD:
+                ret = avc_has_perm(sid, sid, SECCLASS_BPF, BPF__PROG_LOAD,
+                                   NULL);
+                break;
+        default:
+                ret = 0;
+                break;
+        }
+        return ret;
+}
+static u32 bpf_map_fmode_to_av(fmode_t fmode)
+{
+        u32 av = 0;
+        if (fmode & FMODE_READ)
+                av |= BPF__MAP_READ;
+        if (fmode & FMODE_WRITE)
+                av |= BPF__MAP_WRITE;
+        return av;
+}
+/* This function will check the file pass through unix socket or binder to see
+ * if it is a bpf related object. And apply correspinding checks on the bpf
+ * object based on the type. The bpf maps and programs, not like other files and
+ * socket, are using a shared anonymous inode inside the kernel as their inode.
+ * So checking that inode cannot identify if the process have privilege to
+ * access the bpf object and that's why we have to add this additional check in
+ * selinux_file_receive and selinux_binder_transfer_files.
+ */
+static int bpf_fd_pass(struct file *file, u32 sid)
+{
+        struct bpf_security_struct *bpfsec;
+        struct bpf_prog *prog;
+        struct bpf_map *map;
+        int ret;
+        if (file->f_op == &bpf_map_fops) {
+                map = file->private_data;
+                bpfsec = map->security;
+                ret = avc_has_perm(sid, bpfsec->sid, SECCLASS_BPF,
+                                   bpf_map_fmode_to_av(file->f_mode), NULL);
+                if (ret)
+                        return ret;
+        } else if (file->f_op == &bpf_prog_fops) {
+                prog = file->private_data;
+                bpfsec = prog->aux->security;
+                ret = avc_has_perm(sid, bpfsec->sid, SECCLASS_BPF,
+                                   BPF__PROG_RUN, NULL);
+                if (ret)
+                        return ret;
+        }
+        return 0;
+}
+static int selinux_bpf_map(struct bpf_map *map, fmode_t fmode)
+{
+        u32 sid = current_sid();
+        struct bpf_security_struct *bpfsec;
+        bpfsec = map->security;
+        return avc_has_perm(sid, bpfsec->sid, SECCLASS_BPF,
+                            bpf_map_fmode_to_av(fmode), NULL);
+}
+static int selinux_bpf_prog(struct bpf_prog *prog)
+{
+        u32 sid = current_sid();
+        struct bpf_security_struct *bpfsec;
+        bpfsec = prog->aux->security;
+        return avc_has_perm(sid, bpfsec->sid, SECCLASS_BPF,
+                            BPF__PROG_RUN, NULL);
+}
+static int selinux_bpf_map_alloc(struct bpf_map *map)
+{
+        struct bpf_security_struct *bpfsec;
+        bpfsec = kzalloc(sizeof(*bpfsec), GFP_KERNEL);
+        if (!bpfsec)
+                return -ENOMEM;
+        bpfsec->sid = current_sid();
+        map->security = bpfsec;
+        return 0;
+}
+static void selinux_bpf_map_free(struct bpf_map *map)
+{
+        struct bpf_security_struct *bpfsec = map->security;
+        map->security = NULL;
+        kfree(bpfsec);
+}
+static int selinux_bpf_prog_alloc(struct bpf_prog_aux *aux)
+{
+        struct bpf_security_struct *bpfsec;
+        bpfsec = kzalloc(sizeof(*bpfsec), GFP_KERNEL);
+        if (!bpfsec)
+                return -ENOMEM;
+        bpfsec->sid = current_sid();
+        aux->security = bpfsec;
+        return 0;
+}
+static void selinux_bpf_prog_free(struct bpf_prog_aux *aux)
+{
+        struct bpf_security_struct *bpfsec = aux->security;
+        aux->security = NULL;
+        kfree(bpfsec);
+}
+#endif
 static struct security_hook_list selinux_hooks[] __lsm_ro_after_init = {
        LSM_HOOK_INIT(binder_set_context_mgr, selinux_binder_set_context_mgr),
        LSM_HOOK_INIT(binder_transaction, selinux_binder_transaction),
@@ -6471,6 +6612,16 @@ static struct security_hook_list selinux_hooks[] __lsm_ro_after_init = {
        LSM_HOOK_INIT(audit_rule_match, selinux_audit_rule_match),
        LSM_HOOK_INIT(audit_rule_free, selinux_audit_rule_free),
 #endif
+#ifdef CONFIG_BPF_SYSCALL
+        LSM_HOOK_INIT(bpf, selinux_bpf),
+        LSM_HOOK_INIT(bpf_map, selinux_bpf_map),
+        LSM_HOOK_INIT(bpf_prog, selinux_bpf_prog),
+        LSM_HOOK_INIT(bpf_map_alloc_security, selinux_bpf_map_alloc),
+        LSM_HOOK_INIT(bpf_prog_alloc_security, selinux_bpf_prog_alloc),
+        LSM_HOOK_INIT(bpf_map_free_security, selinux_bpf_map_free),
+        LSM_HOOK_INIT(bpf_prog_free_security, selinux_bpf_prog_free),
+#endif
 };
 static __init int selinux_init(void)
diff --git a/security/selinux/include/classmap.h b/security/selinux/include/classmap.h
index cc35695d97b4..acdee7795297 100644
--- a/security/selinux/include/classmap.h
+++ b/security/selinux/include/classmap.h
@@ -238,6 +238,8 @@ struct security_class_mapping secclass_map[] = {
          { "access", NULL } },
        { "infiniband_endport",
          { "manage_subnet", NULL } },
+        { "bpf",
+          {"map_create", "map_read", "map_write", "prog_load", "prog_run"} },
        { NULL }
  };
diff --git a/security/selinux/include/objsec.h b/security/selinux/include/objsec.h
index 1649cd18eb0b..3d54468ce334 100644
--- a/security/selinux/include/objsec.h
+++ b/security/selinux/include/objsec.h
@@ -150,6 +150,10 @@ struct pkey_security_struct {
        u32     sid;    /* SID of pkey */
 };
+struct bpf_security_struct {
+        u32 sid;  /*SID of bpf obj creater*/
+};
 extern unsigned int selinux_checkreqprot;
 #endif /* _SELINUX_OBJSEC_H_ */
diff --git a/security/selinux/ss/conditional.c b/security/selinux/ss/conditional.c
index 771c96afe1d5..c91543a617ac 100644
--- a/security/selinux/ss/conditional.c
+++ b/security/selinux/ss/conditional.c
@@ -361,7 +361,6 @@ static int cond_read_av_list(struct policydb *p, void *fp, struct cond_av_list *
        *ret_list = NULL;
-        len = 0;
        rc = next_entry(buf, fp, sizeof(u32));
        if (rc)
                return rc;
diff --git a/security/selinux/ss/hashtab.c b/security/selinux/ss/hashtab.c
index 6bd6dcd954fa..fe25b3fb2154 100644
--- a/security/selinux/ss/hashtab.c
+++ b/security/selinux/ss/hashtab.c
@@ -10,6 +10,8 @@
 #include <linux/sched.h>
 #include "hashtab.h"
+static struct kmem_cache *hashtab_node_cachep;
 struct hashtab *hashtab_create(u32 (*hash_value)(struct hashtab *h, const void *key),
                               int (*keycmp)(struct hashtab *h, const void *key1, const void *key2),
                               u32 size)
@@ -58,7 +60,7 @@ int hashtab_insert(struct hashtab *h, void *key, void *datum)
        if (cur && (h->keycmp(h, key, cur->key) == 0))
                return -EEXIST;
-        newnode = kzalloc(sizeof(*newnode), GFP_KERNEL);
+        newnode = kmem_cache_zalloc(hashtab_node_cachep, GFP_KERNEL);
        if (!newnode)
                return -ENOMEM;
        newnode->key = key;
@@ -107,7 +109,7 @@ void hashtab_destroy(struct hashtab *h)
                while (cur) {
                        temp = cur;
                        cur = cur->next;
-                        kfree(temp);
+                        kmem_cache_free(hashtab_node_cachep, temp);
                }
                h->htable[i] = NULL;
        }
@@ -149,7 +151,7 @@ void hashtab_stat(struct hashtab *h, struct hashtab_info *info)
        slots_used = 0;
        max_chain_len = 0;
-        for (slots_used = max_chain_len = i = 0; i < h->size; i++) {
+        for (i = 0; i < h->size; i++) {
                cur = h->htable[i];
                if (cur) {
                        slots_used++;
@@ -167,3 +169,14 @@ void hashtab_stat(struct hashtab *h, struct hashtab_info *info)
        info->slots_used = slots_used;
        info->max_chain_len = max_chain_len;
 }
+void hashtab_cache_init(void)
+{
+                hashtab_node_cachep = kmem_cache_create("hashtab_node",
+                        sizeof(struct hashtab_node),
+                        0, SLAB_PANIC, NULL);
+}
+void hashtab_cache_destroy(void)
+{
+                kmem_cache_destroy(hashtab_node_cachep);
+}
diff --git a/security/selinux/ss/hashtab.h b/security/selinux/ss/hashtab.h
index 3e3e42bfd150..6183ee2a2e7a 100644
--- a/security/selinux/ss/hashtab.h
+++ b/security/selinux/ss/hashtab.h
@@ -85,4 +85,8 @@ int hashtab_map(struct hashtab *h,
 /* Fill info with some hash table statistics */
 void hashtab_stat(struct hashtab *h, struct hashtab_info *info);
+/* Use kmem_cache for hashtab_node */
+void hashtab_cache_init(void);
+void hashtab_cache_destroy(void);
 #endif  /* _SS_HASHTAB_H */
diff --git a/security/selinux/ss/services.c b/security/selinux/ss/services.c
index e4a1c0dc561a..33cfe5d3d6cb 100644
--- a/security/selinux/ss/services.c
+++ b/security/selinux/ss/services.c
@@ -2060,10 +2060,12 @@ int security_load_policy(void *data, size_t len)
        if (!ss_initialized) {
                avtab_cache_init();
                ebitmap_cache_init();
+                hashtab_cache_init();
                rc = policydb_read(&policydb, fp);
                if (rc) {
                        avtab_cache_destroy();
                        ebitmap_cache_destroy();
+                        hashtab_cache_destroy();
                        goto out;
                }
@@ -2075,6 +2077,7 @@ int security_load_policy(void *data, size_t len)
                        policydb_destroy(&policydb);
                        avtab_cache_destroy();
                        ebitmap_cache_destroy();
+                        hashtab_cache_destroy();
                        goto out;
                }
@@ -2083,6 +2086,7 @@ int security_load_policy(void *data, size_t len)
                        policydb_destroy(&policydb);
                        avtab_cache_destroy();
                        ebitmap_cache_destroy();
+                        hashtab_cache_destroy();
                        goto out;
                }
diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c
index 286171a16ed2..14cc7940b36d 100644
--- a/security/smack/smack_lsm.c
+++ b/security/smack/smack_lsm.c
@@ -4600,6 +4600,82 @@ static int smack_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
        return 0;
 }
+static int smack_inode_copy_up(struct dentry *dentry, struct cred **new)
+{
+        struct task_smack *tsp;
+        struct smack_known *skp;
+        struct inode_smack *isp;
+        struct cred *new_creds = *new;
+        if (new_creds == NULL) {
+                new_creds = prepare_creds();
+                if (new_creds == NULL)
+                        return -ENOMEM;
+        }
+        tsp = new_creds->security;
+        /*
+         * Get label from overlay inode and set it in create_sid
+         */
+        isp = d_inode(dentry->d_parent)->i_security;
+        skp = isp->smk_inode;
+        tsp->smk_task = skp;
+        *new = new_creds;
+        return 0;
+}
+static int smack_inode_copy_up_xattr(const char *name)
+{
+        /*
+         * Return 1 if this is the smack access Smack attribute.
+         */
+        if (strcmp(name, XATTR_NAME_SMACK) == 0)
+                return 1;
+        return -EOPNOTSUPP;
+}
+static int smack_dentry_create_files_as(struct dentry *dentry, int mode,
+                                        struct qstr *name,
+                                        const struct cred *old,
+                                        struct cred *new)
+{
+        struct task_smack *otsp = old->security;
+        struct task_smack *ntsp = new->security;
+        struct inode_smack *isp;
+        int may;
+        /*
+         * Use the process credential unless all of
+         * the transmuting criteria are met
+         */
+        ntsp->smk_task = otsp->smk_task;
+        /*
+         * the attribute of the containing directory
+         */
+        isp = d_inode(dentry->d_parent)->i_security;
+        if (isp->smk_flags & SMK_INODE_TRANSMUTE) {
+                rcu_read_lock();
+                may = smk_access_entry(otsp->smk_task->smk_known,
+                                       isp->smk_inode->smk_known,
+                                       &otsp->smk_task->smk_rules);
+                rcu_read_unlock();
+                /*
+                 * If the directory is transmuting and the rule
+                 * providing access is transmuting use the containing
+                 * directory label instead of the process label.
+                 */
+                if (may > 0 && (may & MAY_TRANSMUTE))
+                        ntsp->smk_task = isp->smk_inode;
+        }
+        return 0;
+}
 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),
@@ -4735,6 +4811,9 @@ static struct security_hook_list smack_hooks[] __lsm_ro_after_init = {
        LSM_HOOK_INIT(inode_notifysecctx, smack_inode_notifysecctx),
        LSM_HOOK_INIT(inode_setsecctx, smack_inode_setsecctx),
        LSM_HOOK_INIT(inode_getsecctx, smack_inode_getsecctx),
+        LSM_HOOK_INIT(inode_copy_up, smack_inode_copy_up),
+        LSM_HOOK_INIT(inode_copy_up_xattr, smack_inode_copy_up_xattr),
+        LSM_HOOK_INIT(dentry_create_files_as, smack_dentry_create_files_as),
 };
diff --git a/security/tomoyo/audit.c b/security/tomoyo/audit.c
index d330b060dcff..0f73fe30e37a 100644
--- a/security/tomoyo/audit.c
+++ b/security/tomoyo/audit.c
@@ -157,7 +157,7 @@ static char *tomoyo_print_header(struct tomoyo_request_info *r)
        if (!buffer)
                return NULL;
-        tomoyo_convert_time(get_seconds(), &stamp);
+        tomoyo_convert_time(ktime_get_real_seconds(), &stamp);
        pos = snprintf(buffer, tomoyo_buffer_len - 1,
                       "#%04u/%02u/%02u %02u:%02u:%02u# profile=%u mode=%s "
diff --git a/security/tomoyo/common.c b/security/tomoyo/common.c
index 21691b99e61f..25eed4b0b0e8 100644
--- a/security/tomoyo/common.c
+++ b/security/tomoyo/common.c
@@ -2257,7 +2257,7 @@ static const char * const tomoyo_memory_headers[TOMOYO_MAX_MEMORY_STAT] = {
 /* Timestamp counter for last updated. */
 static unsigned int tomoyo_stat_updated[TOMOYO_MAX_POLICY_STAT];
 /* Counter for number of updates. */
-static unsigned int tomoyo_stat_modified[TOMOYO_MAX_POLICY_STAT];
+static time64_t tomoyo_stat_modified[TOMOYO_MAX_POLICY_STAT];
 /**
 * tomoyo_update_stat - Update statistic counters.
@@ -2272,7 +2272,7 @@ void tomoyo_update_stat(const u8 index)
         * I don't use atomic operations because race condition is not fatal.
         */
        tomoyo_stat_updated[index]++;
-        tomoyo_stat_modified[index] = get_seconds();
+        tomoyo_stat_modified[index] = ktime_get_real_seconds();
 }
 /**
diff --git a/security/tomoyo/common.h b/security/tomoyo/common.h
index e4097d7994b1..7adccdd8e36d 100644
--- a/security/tomoyo/common.h
+++ b/security/tomoyo/common.h
@@ -1037,7 +1037,7 @@ void tomoyo_check_acl(struct tomoyo_request_info *r,
                      bool (*check_entry) (struct tomoyo_request_info *,
                                           const struct tomoyo_acl_info *));
 void tomoyo_check_profile(void);
-void tomoyo_convert_time(time_t time, struct tomoyo_time *stamp);
+void tomoyo_convert_time(time64_t time, struct tomoyo_time *stamp);
 void tomoyo_del_condition(struct list_head *element);
 void tomoyo_fill_path_info(struct tomoyo_path_info *ptr);
 void tomoyo_get_attributes(struct tomoyo_obj_info *obj);
diff --git a/security/tomoyo/util.c b/security/tomoyo/util.c
index 580b318910f1..d3d9d9f1edb0 100644
--- a/security/tomoyo/util.c
+++ b/security/tomoyo/util.c
@@ -87,38 +87,17 @@ const u8 tomoyo_index2category[TOMOYO_MAX_MAC_INDEX] = {
 * @stamp: Pointer to "struct tomoyo_time".
 *
 * Returns nothing.
- *
- * This function does not handle Y2038 problem.
 */
-void tomoyo_convert_time(time_t time, struct tomoyo_time *stamp)
+void tomoyo_convert_time(time64_t time64, struct tomoyo_time *stamp)
 {
-        static const u16 tomoyo_eom[2][12] = {
+        struct tm tm;
-                { 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
+        time64_to_tm(time64, 0, &tm);
-                { 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
+        stamp->sec = tm.tm_sec;
-        };
+        stamp->min = tm.tm_min;
-        u16 y;
+        stamp->hour = tm.tm_hour;
-        u8 m;
+        stamp->day = tm.tm_mday;
-        bool r;
+        stamp->month = tm.tm_mon + 1;
-        stamp->sec = time % 60;
+        stamp->year = tm.tm_year + 1900;
-        time /= 60;
-        stamp->min = time % 60;
-        time /= 60;
-        stamp->hour = time % 24;
-        time /= 24;
-        for (y = 1970; ; y++) {
-                const unsigned short days = (y & 3) ? 365 : 366;
-                if (time < days)
-                        break;
-                time -= days;
-        }
-        r = (y & 3) == 0;
-        for (m = 0; m < 11 && time >= tomoyo_eom[r][m]; m++)
-                ;
-        if (m)
-                time -= tomoyo_eom[r][m - 1];
-        stamp->year = y;
-        stamp->month = ++m;
-        stamp->day = ++time;
 }
 /**