Merge branch 'master' into next

10 files changed, 132 insertions, 158 deletions

diff --git a/security/Makefile b/security/Makefile
index bb44e350c618..da20a193c8dd 100644
--- a/security/Makefile
+++ b/security/Makefile
@@ -8,7 +8,8 @@ subdir-$(CONFIG_SECURITY_SMACK)		+= smack
 subdir-$(CONFIG_SECURITY_TOMOYO)        += tomoyo
 
 # always enable default capabilities
-obj-y           += commoncap.o min_addr.o
+obj-y                                   += commoncap.o
+obj-$(CONFIG_MMU)                       += min_addr.o
 
 # Object file lists
 obj-$(CONFIG_SECURITY)                  += security.o capability.o
diff --git a/security/integrity/ima/ima.h b/security/integrity/ima/ima.h
index 165eb5397ea5..c41afe6639a0 100644
--- a/security/integrity/ima/ima.h
+++ b/security/integrity/ima/ima.h
@@ -97,7 +97,6 @@ static inline unsigned long ima_hash_key(u8 *digest)
 
 /* iint cache flags */
 #define IMA_MEASURED            1
-#define IMA_IINT_DUMP_STACK     512
 
 /* integrity data associated with an inode */
 struct ima_iint_cache {
@@ -128,8 +127,6 @@ void ima_template_show(struct seq_file *m, void *e,
  */
 struct ima_iint_cache *ima_iint_insert(struct inode *inode);
 struct ima_iint_cache *ima_iint_find_get(struct inode *inode);
-struct ima_iint_cache *ima_iint_find_insert_get(struct inode *inode);
-void ima_iint_delete(struct inode *inode);
 void iint_free(struct kref *kref);
 void iint_rcu_free(struct rcu_head *rcu);
 
diff --git a/security/integrity/ima/ima_iint.c b/security/integrity/ima/ima_iint.c
index a4e2b1dac943..fa592ff1ac1c 100644
--- a/security/integrity/ima/ima_iint.c
+++ b/security/integrity/ima/ima_iint.c
@@ -19,8 +19,6 @@
 #include <linux/radix-tree.h>
 #include "ima.h"
 
-#define ima_iint_delete ima_inode_free
-
 RADIX_TREE(ima_iint_store, GFP_ATOMIC);
 DEFINE_SPINLOCK(ima_iint_lock);
 
@@ -45,22 +43,21 @@ out:
         return iint;
 }
 
-/* Allocate memory for the iint associated with the inode
- * from the iint_cache slab, initialize the iint, and
- * insert it into the radix tree.
- *
- * On success return a pointer to the iint; on failure return NULL.
+/**
+ * ima_inode_alloc - allocate an iint associated with an inode
+ * @inode: pointer to the inode
  */
-struct ima_iint_cache *ima_iint_insert(struct inode *inode)
+int ima_inode_alloc(struct inode *inode)
 {
         struct ima_iint_cache *iint = NULL;
         int rc = 0;
 
         if (!ima_initialized)
-                return iint;
+                return 0;
+
         iint = kmem_cache_alloc(iint_cache, GFP_NOFS);
         if (!iint)
-                return iint;
+                return -ENOMEM;
 
         rc = radix_tree_preload(GFP_NOFS);
         if (rc < 0)
@@ -70,65 +67,13 @@ struct ima_iint_cache *ima_iint_insert(struct inode *inode)
         rc = radix_tree_insert(&ima_iint_store, (unsigned long)inode, iint);
         spin_unlock(&ima_iint_lock);
 out:
-        if (rc < 0) {
+        if (rc < 0)
                 kmem_cache_free(iint_cache, iint);
-                if (rc == -EEXIST) {
-                        spin_lock(&ima_iint_lock);
-                        iint = radix_tree_lookup(&ima_iint_store,
-                                                 (unsigned long)inode);
-                        spin_unlock(&ima_iint_lock);
-                } else
-                        iint = NULL;
-        }
-        radix_tree_preload_end();
-        return iint;
-}
-
-/**
- * ima_inode_alloc - allocate an iint associated with an inode
- * @inode: pointer to the inode
- *
- * Return 0 on success, 1 on failure.
- */
-int ima_inode_alloc(struct inode *inode)
-{
-        struct ima_iint_cache *iint;
-
-        if (!ima_initialized)
-                return 0;
-
-        iint = ima_iint_insert(inode);
-        if (!iint)
-                return 1;
-        return 0;
-}
-
-/* ima_iint_find_insert_get - get the iint associated with an inode
- *
- * Most insertions are done at inode_alloc, except those allocated
- * before late_initcall. When the iint does not exist, allocate it,
- * initialize and insert it, and increment the iint refcount.
- *
- * (Can't initialize at security_initcall before any inodes are
- * allocated, got to wait at least until proc_init.)
- *
- *  Return the iint.
- */
-struct ima_iint_cache *ima_iint_find_insert_get(struct inode *inode)
-{
-        struct ima_iint_cache *iint = NULL;
 
-        iint = ima_iint_find_get(inode);
-        if (iint)
-                return iint;
-
-        iint = ima_iint_insert(inode);
-        if (iint)
-                kref_get(&iint->refcount);
+        radix_tree_preload_end();
 
-        return iint;
+        return rc;
 }
-EXPORT_SYMBOL_GPL(ima_iint_find_insert_get);
 
 /* iint_free - called when the iint refcount goes to zero */
 void iint_free(struct kref *kref)
@@ -164,12 +109,12 @@ void iint_rcu_free(struct rcu_head *rcu_head)
 }
 
 /**
- * ima_iint_delete - called on integrity_inode_free
+ * ima_inode_free - called on security_inode_free
  * @inode: pointer to the inode
  *
  * Free the integrity information(iint) associated with an inode.
  */
-void ima_iint_delete(struct inode *inode)
+void ima_inode_free(struct inode *inode)
 {
         struct ima_iint_cache *iint;
 
diff --git a/security/integrity/ima/ima_main.c b/security/integrity/ima/ima_main.c
index b85e61bcf246..a89f44d5e030 100644
--- a/security/integrity/ima/ima_main.c
+++ b/security/integrity/ima/ima_main.c
@@ -13,8 +13,8 @@
  * License.
  *
  * File: ima_main.c
- *             implements the IMA hooks: ima_bprm_check, ima_file_mmap,
- *             and ima_path_check.
+ *      implements the IMA hooks: ima_bprm_check, ima_file_mmap,
+ *      and ima_path_check.
  */
 #include <linux/module.h>
 #include <linux/file.h>
@@ -35,6 +35,100 @@ static int __init hash_setup(char *str)
 }
 __setup("ima_hash=", hash_setup);
 
+struct ima_imbalance {
+        struct hlist_node node;
+        unsigned long fsmagic;
+};
+
+/*
+ * ima_limit_imbalance - emit one imbalance message per filesystem type
+ *
+ * Maintain list of filesystem types that do not measure files properly.
+ * Return false if unknown, true if known.
+ */
+static bool ima_limit_imbalance(struct file *file)
+{
+        static DEFINE_SPINLOCK(ima_imbalance_lock);
+        static HLIST_HEAD(ima_imbalance_list);
+
+        struct super_block *sb = file->f_dentry->d_sb;
+        struct ima_imbalance *entry;
+        struct hlist_node *node;
+        bool found = false;
+
+        rcu_read_lock();
+        hlist_for_each_entry_rcu(entry, node, &ima_imbalance_list, node) {
+                if (entry->fsmagic == sb->s_magic) {
+                        found = true;
+                        break;
+                }
+        }
+        rcu_read_unlock();
+        if (found)
+                goto out;
+
+        entry = kmalloc(sizeof(*entry), GFP_NOFS);
+        if (!entry)
+                goto out;
+        entry->fsmagic = sb->s_magic;
+        spin_lock(&ima_imbalance_lock);
+        /*
+         * we could have raced and something else might have added this fs
+         * to the list, but we don't really care
+         */
+        hlist_add_head_rcu(&entry->node, &ima_imbalance_list);
+        spin_unlock(&ima_imbalance_lock);
+        printk(KERN_INFO "IMA: unmeasured files on fsmagic: %lX\n",
+               entry->fsmagic);
+out:
+        return found;
+}
+
+/*
+ * Update the counts given an fmode_t
+ */
+static void ima_inc_counts(struct ima_iint_cache *iint, fmode_t mode)
+{
+        BUG_ON(!mutex_is_locked(&iint->mutex));
+
+        iint->opencount++;
+        if ((mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
+                iint->readcount++;
+        if (mode & FMODE_WRITE)
+                iint->writecount++;
+}
+
+/*
+ * Decrement ima counts
+ */
+static void ima_dec_counts(struct ima_iint_cache *iint, struct inode *inode,
+                           struct file *file)
+{
+        mode_t mode = file->f_mode;
+        BUG_ON(!mutex_is_locked(&iint->mutex));
+
+        iint->opencount--;
+        if ((mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
+                iint->readcount--;
+        if (mode & FMODE_WRITE) {
+                iint->writecount--;
+                if (iint->writecount == 0) {
+                        if (iint->version != inode->i_version)
+                                iint->flags &= ~IMA_MEASURED;
+                }
+        }
+
+        if (((iint->opencount < 0) ||
+             (iint->readcount < 0) ||
+             (iint->writecount < 0)) &&
+            !ima_limit_imbalance(file)) {
+                printk(KERN_INFO "%s: open/free imbalance (r:%ld w:%ld o:%ld)\n",
+                       __FUNCTION__, iint->readcount, iint->writecount,
+                       iint->opencount);
+                dump_stack();
+        }
+}
+
 /**
  * ima_file_free - called on __fput()
  * @file: pointer to file structure being freed
@@ -54,29 +148,7 @@ void ima_file_free(struct file *file)
                 return;
 
         mutex_lock(&iint->mutex);
-        if (iint->opencount <= 0) {
-                printk(KERN_INFO
-                       "%s: %s open/free imbalance (r:%ld w:%ld o:%ld f:%ld)\n",
-                       __FUNCTION__, file->f_dentry->d_name.name,
-                       iint->readcount, iint->writecount,
-                       iint->opencount, atomic_long_read(&file->f_count));
-                if (!(iint->flags & IMA_IINT_DUMP_STACK)) {
-                        dump_stack();
-                        iint->flags |= IMA_IINT_DUMP_STACK;
-                }
-        }
-        iint->opencount--;
-
-        if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
-                iint->readcount--;
-
-        if (file->f_mode & FMODE_WRITE) {
-                iint->writecount--;
-                if (iint->writecount == 0) {
-                        if (iint->version != inode->i_version)
-                                iint->flags &= ~IMA_MEASURED;
-                }
-        }
+        ima_dec_counts(iint, inode, file);
         mutex_unlock(&iint->mutex);
         kref_put(&iint->refcount, iint_free);
 }
@@ -116,8 +188,7 @@ static int get_path_measurement(struct ima_iint_cache *iint, struct file *file,
 {
         int rc = 0;
 
-        iint->opencount++;
-        iint->readcount++;
+        ima_inc_counts(iint, file->f_mode);
 
         rc = ima_collect_measurement(iint, file);
         if (!rc)
@@ -125,15 +196,6 @@ static int get_path_measurement(struct ima_iint_cache *iint, struct file *file,
         return rc;
 }
 
-static void ima_update_counts(struct ima_iint_cache *iint, int mask)
-{
-        iint->opencount++;
-        if ((mask & MAY_WRITE) || (mask == 0))
-                iint->writecount++;
-        else if (mask & (MAY_READ | MAY_EXEC))
-                iint->readcount++;
-}
-
 /**
  * ima_path_check - based on policy, collect/store measurement.
  * @path: contains a pointer to the path to be measured
@@ -152,7 +214,7 @@ static void ima_update_counts(struct ima_iint_cache *iint, int mask)
  * Always return 0 and audit dentry_open failures.
  * (Return code will be based upon measurement appraisal.)
  */
-int ima_path_check(struct path *path, int mask, int update_counts)
+int ima_path_check(struct path *path, int mask)
 {
         struct inode *inode = path->dentry->d_inode;
         struct ima_iint_cache *iint;
@@ -161,13 +223,11 @@ int ima_path_check(struct path *path, int mask, int update_counts)
 
         if (!ima_initialized || !S_ISREG(inode->i_mode))
                 return 0;
-        iint = ima_iint_find_insert_get(inode);
+        iint = ima_iint_find_get(inode);
         if (!iint)
                 return 0;
 
         mutex_lock(&iint->mutex);
-        if (update_counts)
-                ima_update_counts(iint, mask);
 
         rc = ima_must_measure(iint, inode, MAY_READ, PATH_CHECK);
         if (rc < 0)
@@ -219,7 +279,7 @@ static int process_measurement(struct file *file, const unsigned char *filename,
 
         if (!ima_initialized || !S_ISREG(inode->i_mode))
                 return 0;
-        iint = ima_iint_find_insert_get(inode);
+        iint = ima_iint_find_get(inode);
         if (!iint)
                 return -ENOMEM;
 
@@ -238,39 +298,6 @@ out:
 }
 
 /*
- * ima_counts_put - decrement file counts
- *
- * File counts are incremented in ima_path_check. On file open
- * error, such as ETXTBSY, decrement the counts to prevent
- * unnecessary imbalance messages.
- */
-void ima_counts_put(struct path *path, int mask)
-{
-        struct inode *inode = path->dentry->d_inode;
-        struct ima_iint_cache *iint;
-
-        /* The inode may already have been freed, freeing the iint
-         * with it. Verify the inode is not NULL before dereferencing
-         * it.
-         */
-        if (!ima_initialized || !inode || !S_ISREG(inode->i_mode))
-                return;
-        iint = ima_iint_find_insert_get(inode);
-        if (!iint)
-                return;
-
-        mutex_lock(&iint->mutex);
-        iint->opencount--;
-        if ((mask & MAY_WRITE) || (mask == 0))
-                iint->writecount--;
-        else if (mask & (MAY_READ | MAY_EXEC))
-                iint->readcount--;
-        mutex_unlock(&iint->mutex);
-
-        kref_put(&iint->refcount, iint_free);
-}
-
-/*
  * ima_counts_get - increment file counts
  *
  * - for IPC shm and shmat file.
@@ -286,16 +313,11 @@ void ima_counts_get(struct file *file)
 
         if (!ima_initialized || !S_ISREG(inode->i_mode))
                 return;
-        iint = ima_iint_find_insert_get(inode);
+        iint = ima_iint_find_get(inode);
         if (!iint)
                 return;
         mutex_lock(&iint->mutex);
-        iint->opencount++;
-        if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
-                iint->readcount++;
-
-        if (file->f_mode & FMODE_WRITE)
-                iint->writecount++;
+        ima_inc_counts(iint, file->f_mode);
         mutex_unlock(&iint->mutex);
 
         kref_put(&iint->refcount, iint_free);
diff --git a/security/keys/keyctl.c b/security/keys/keyctl.c
index 06ec722897be..e9c2e7c584d9 100644
--- a/security/keys/keyctl.c
+++ b/security/keys/keyctl.c
@@ -1194,7 +1194,7 @@ long keyctl_get_security(key_serial_t keyid,
                  * have the authorisation token handy */
                 instkey = key_get_instantiation_authkey(keyid);
                 if (IS_ERR(instkey))
-                        return PTR_ERR(key_ref);
+                        return PTR_ERR(instkey);
                 key_put(instkey);
 
                 key_ref = lookup_user_key(keyid, KEY_LOOKUP_PARTIAL, 0);
@@ -1236,6 +1236,7 @@ long keyctl_get_security(key_serial_t keyid,
  */
 long keyctl_session_to_parent(void)
 {
+#ifdef TIF_NOTIFY_RESUME
         struct task_struct *me, *parent;
         const struct cred *mycred, *pcred;
         struct cred *cred, *oldcred;
@@ -1326,6 +1327,15 @@ not_permitted:
 error_keyring:
         key_ref_put(keyring_r);
         return ret;
+
+#else /* !TIF_NOTIFY_RESUME */
+        /*
+         * To be removed when TIF_NOTIFY_RESUME has been implemented on
+         * m68k/xtensa
+         */
+#warning TIF_NOTIFY_RESUME not implemented
+        return -EOPNOTSUPP;
+#endif /* !TIF_NOTIFY_RESUME */
 }
 
 /*****************************************************************************/
diff --git a/security/min_addr.c b/security/min_addr.c
index fc43c9d37084..e86f297522bf 100644
--- a/security/min_addr.c
+++ b/security/min_addr.c
@@ -43,7 +43,7 @@ int mmap_min_addr_handler(struct ctl_table *table, int write,
         return ret;
 }
 
-int __init init_mmap_min_addr(void)
+static int __init init_mmap_min_addr(void)
 {
         update_mmap_min_addr();
 
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 7a374c2eb043..9a2ee845e9d4 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -2365,7 +2365,7 @@ static void selinux_bprm_committing_creds(struct linux_binprm *bprm)
                         initrlim = init_task.signal->rlim + i;
                         rlim->rlim_cur = min(rlim->rlim_max, initrlim->rlim_cur);
                 }
-                update_rlimit_cpu(rlim->rlim_cur);
+                update_rlimit_cpu(current->signal->rlim[RLIMIT_CPU].rlim_cur);
         }
 }
 
diff --git a/security/selinux/netlabel.c b/security/selinux/netlabel.c
index e68823741ad5..2534400317c5 100644
--- a/security/selinux/netlabel.c
+++ b/security/selinux/netlabel.c
@@ -204,7 +204,7 @@ int selinux_netlbl_skbuff_getsid(struct sk_buff *skb,
  *
  * Description
  * Call the NetLabel mechanism to set the label of a packet using @sid.
- * Returns zero on auccess, negative values on failure.
+ * Returns zero on success, negative values on failure.
  *
  */
 int selinux_netlbl_skbuff_setsid(struct sk_buff *skb,
diff --git a/security/selinux/ss/services.c b/security/selinux/ss/services.c
index 9ec24169ccd7..3b42b154d87c 100644
--- a/security/selinux/ss/services.c
+++ b/security/selinux/ss/services.c
@@ -806,7 +806,7 @@ int security_bounded_transition(u32 old_sid, u32 new_sid)
                 goto out;
         }
 
-        /* type/domain unchaned */
+        /* type/domain unchanged */
         if (old_context->type == new_context->type) {
                 rc = 0;
                 goto out;
diff --git a/security/tomoyo/file.c b/security/tomoyo/file.c
index 075392c052b4..cfcb096ee97a 100644
--- a/security/tomoyo/file.c
+++ b/security/tomoyo/file.c
@@ -12,7 +12,6 @@
 #include "common.h"
 #include "tomoyo.h"
 #include "realpath.h"
-#define ACC_MODE(x) ("\000\004\002\006"[(x)&O_ACCMODE])
 
 /*
  * tomoyo_globally_readable_file_entry is a structure which is used for holding