tracing: Apply trace_clock changes to instance max buffer

[mirror_ubuntu-artful-kernel.git] / kernel / audit_tree.c

diff --git a/kernel/audit_tree.c b/kernel/audit_tree.c
index 5cfd1ea18de0a23de57e97e9fe52da2205f0d854..011d46e5f73fb448634c603fc474f479fe3e790b 100644 (file)
--- a/kernel/audit_tree.c
+++ b/kernel/audit_tree.c
@@ -155,7 +155,7 @@ static struct audit_chunk *alloc_chunk(int count)
                INIT_LIST_HEAD(&chunk->owners[i].list);
                chunk->owners[i].index = i;
        }
-       fsnotify_init_mark(&chunk->mark, audit_tree_destroy_watch);
+       fsnotify_init_mark(&chunk->mark, audit_tree_group);
        chunk->mark.mask = FS_IN_IGNORED;
        return chunk;
 }
@@ -164,33 +164,54 @@ enum {HASH_SIZE = 128};
 static struct list_head chunk_hash_heads[HASH_SIZE];
 static __cacheline_aligned_in_smp DEFINE_SPINLOCK(hash_lock);
 
-static inline struct list_head *chunk_hash(const struct inode *inode)
+/* Function to return search key in our hash from inode. */
+static unsigned long inode_to_key(const struct inode *inode)
 {
-       unsigned long n = (unsigned long)inode / L1_CACHE_BYTES;
+       return (unsigned long)inode;
+}
+
+/*
+ * Function to return search key in our hash from chunk. Key 0 is special and
+ * should never be present in the hash.
+ */
+static unsigned long chunk_to_key(struct audit_chunk *chunk)
+{
+       /*
+        * We have a reference to the mark so it should be attached to a
+        * connector.
+        */
+       if (WARN_ON_ONCE(!chunk->mark.connector))
+               return 0;
+       return (unsigned long)chunk->mark.connector->inode;
+}
+
+static inline struct list_head *chunk_hash(unsigned long key)
+{
+       unsigned long n = key / L1_CACHE_BYTES;
        return chunk_hash_heads + n % HASH_SIZE;
 }
 
 /* hash_lock & entry->lock is held by caller */
 static void insert_hash(struct audit_chunk *chunk)
 {
-       struct fsnotify_mark *entry = &chunk->mark;
+       unsigned long key = chunk_to_key(chunk);
        struct list_head *list;
 
-       if (!entry->inode)
+       if (!(chunk->mark.flags & FSNOTIFY_MARK_FLAG_ATTACHED))
                return;
-       list = chunk_hash(entry->inode);
+       list = chunk_hash(key);
        list_add_rcu(&chunk->hash, list);
 }
 
 /* called under rcu_read_lock */
 struct audit_chunk *audit_tree_lookup(const struct inode *inode)
 {
-       struct list_head *list = chunk_hash(inode);
+       unsigned long key = inode_to_key(inode);
+       struct list_head *list = chunk_hash(key);
        struct audit_chunk *p;
 
        list_for_each_entry_rcu(p, list, hash) {
-               /* mark.inode may have gone NULL, but who cares? */
-               if (p->mark.inode == inode) {
+               if (chunk_to_key(p) == key) {
                        atomic_long_inc(&p->refs);
                        return p;
                }
@@ -234,11 +255,15 @@ static void untag_chunk(struct node *p)
 
        mutex_lock(&entry->group->mark_mutex);
        spin_lock(&entry->lock);
-       if (chunk->dead || !entry->inode) {
+       /*
+        * mark_mutex protects mark from getting detached and thus also from
+        * mark->connector->inode getting NULL.
+        */
+       if (chunk->dead || !(entry->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {
                spin_unlock(&entry->lock);
                mutex_unlock(&entry->group->mark_mutex);
                if (new)
-                       free_chunk(new);
+                       fsnotify_put_mark(&new->mark);
                goto out;
        }
 
@@ -262,7 +287,7 @@ static void untag_chunk(struct node *p)
        if (!new)
                goto Fallback;
 
-       if (fsnotify_add_mark_locked(&new->mark, entry->group, entry->inode,
+       if (fsnotify_add_mark_locked(&new->mark, entry->connector->inode,
                                     NULL, 1)) {
                fsnotify_put_mark(&new->mark);
                goto Fallback;
@@ -328,7 +353,7 @@ static int create_chunk(struct inode *inode, struct audit_tree *tree)
                return -ENOMEM;
 
        entry = &chunk->mark;
-       if (fsnotify_add_mark(entry, audit_tree_group, inode, NULL, 0)) {
+       if (fsnotify_add_mark(entry, inode, NULL, 0)) {
                fsnotify_put_mark(entry);
                return -ENOSPC;
        }
@@ -367,7 +392,8 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
        struct node *p;
        int n;
 
-       old_entry = fsnotify_find_inode_mark(audit_tree_group, inode);
+       old_entry = fsnotify_find_mark(&inode->i_fsnotify_marks,
+                                      audit_tree_group);
        if (!old_entry)
                return create_chunk(inode, tree);
 
@@ -394,17 +420,21 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
 
        mutex_lock(&old_entry->group->mark_mutex);
        spin_lock(&old_entry->lock);
-       if (!old_entry->inode) {
+       /*
+        * mark_mutex protects mark from getting detached and thus also from
+        * mark->connector->inode getting NULL.
+        */
+       if (!(old_entry->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {
                /* old_entry is being shot, lets just lie */
                spin_unlock(&old_entry->lock);
                mutex_unlock(&old_entry->group->mark_mutex);
                fsnotify_put_mark(old_entry);
-               free_chunk(chunk);
+               fsnotify_put_mark(&chunk->mark);
                return -ENOENT;
        }
 
-       if (fsnotify_add_mark_locked(chunk_entry, old_entry->group,
-                                    old_entry->inode, NULL, 1)) {
+       if (fsnotify_add_mark_locked(chunk_entry,
+                            old_entry->connector->inode, NULL, 1)) {
                spin_unlock(&old_entry->lock);
                mutex_unlock(&old_entry->group->mark_mutex);
                fsnotify_put_mark(chunk_entry);
@@ -589,7 +619,8 @@ int audit_remove_tree_rule(struct audit_krule *rule)
 
 static int compare_root(struct vfsmount *mnt, void *arg)
 {
-       return d_backing_inode(mnt->mnt_root) == arg;
+       return inode_to_key(d_backing_inode(mnt->mnt_root)) ==
+              (unsigned long)arg;
 }
 
 void audit_trim_trees(void)
@@ -624,9 +655,10 @@ void audit_trim_trees(void)
                list_for_each_entry(node, &tree->chunks, list) {
                        struct audit_chunk *chunk = find_chunk(node);
                        /* this could be NULL if the watch is dying else where... */
-                       struct inode *inode = chunk->mark.inode;
                        node->index |= 1U<<31;
-                       if (iterate_mounts(compare_root, inode, root_mnt))
+                       if (iterate_mounts(compare_root,
+                                          (void *)chunk_to_key(chunk),
+                                          root_mnt))
                                node->index &= ~(1U<<31);
                }
                spin_unlock(&hash_lock);
@@ -959,7 +991,8 @@ static int audit_tree_handle_event(struct fsnotify_group *group,
                                   struct fsnotify_mark *inode_mark,
                                   struct fsnotify_mark *vfsmount_mark,
                                   u32 mask, const void *data, int data_type,
-                                  const unsigned char *file_name, u32 cookie)
+                                  const unsigned char *file_name, u32 cookie,
+                                  struct fsnotify_iter_info *iter_info)
 {
        return 0;
 }
@@ -980,6 +1013,7 @@ static void audit_tree_freeing_mark(struct fsnotify_mark *entry, struct fsnotify
 static const struct fsnotify_ops audit_tree_ops = {
        .handle_event = audit_tree_handle_event,
        .freeing_mark = audit_tree_freeing_mark,
+       .free_mark = audit_tree_destroy_watch,
 };
 
 static int __init audit_tree_init(void)