// SPDX-License-Identifier: GPL-2.0#include "audit.h"#include <linux/fsnotify_backend.h>#include <linux/namei.h>#include <linux/mount.h>#include <linux/kthread.h>#include <linux/refcount.h>#include <linux/slab.h> struct audit_tree;struct audit_chunk; struct audit_tree { refcount_t count; int goner; struct audit_chunk *root; struct list_head chunks; struct list_head rules; struct list_head list; struct list_head same_root; struct rcu_head head; char pathname[];}; struct audit_chunk { struct list_head hash; unsigned long key; struct fsnotify_mark *mark; struct list_head trees; /* with root here */ int count; atomic_long_t refs; struct rcu_head head; struct audit_node { struct list_head list; struct audit_tree *owner; unsigned index; /* index; upper bit indicates 'will prune' */ } owners[] __counted_by(count);}; struct audit_tree_mark { struct fsnotify_mark mark; struct audit_chunk *chunk;}; static LIST_HEAD(tree_list);static LIST_HEAD(prune_list);static struct task_struct *prune_thread; /* * One struct chunk is attached to each inode of interest through * audit_tree_mark (fsnotify mark). We replace struct chunk on tagging / * untagging, the mark is stable as long as there is chunk attached. The * association between mark and chunk is protected by hash_lock and * audit_tree_group->mark_mutex. Thus as long as we hold * audit_tree_group->mark_mutex and check that the mark is alive by * FSNOTIFY_MARK_FLAG_ATTACHED flag check, we are sure the mark points to * the current chunk. * * Rules have pointer to struct audit_tree. * Rules have struct list_head rlist forming a list of rules over * the same tree. * References to struct chunk are collected at audit_inode{,_child}() * time and used in AUDIT_TREE rule matching. * These references are dropped at the same time we are calling * audit_free_names(), etc. * * Cyclic lists galore: * tree.chunks anchors chunk.owners[].list hash_lock * tree.rules anchors rule.rlist audit_filter_mutex * chunk.trees anchors tree.same_root hash_lock * chunk.hash is a hash with middle bits of watch.inode as * a hash function. RCU, hash_lock * * tree is refcounted; one reference for "some rules on rules_list refer to * it", one for each chunk with pointer to it. * * chunk is refcounted by embedded .refs. Mark associated with the chunk holds * one chunk reference. This reference is dropped either when a mark is going * to be freed (corresponding inode goes away) or when chunk attached to the * mark gets replaced. This reference must be dropped using * audit_mark_put_chunk() to make sure the reference is dropped only after RCU * grace period as it protects RCU readers of the hash table. * * node.index allows to get from node.list to containing chunk. * MSB of that sucker is stolen to mark taggings that we might have to * revert - several operations have very unpleasant cleanup logics and * that makes a difference. Some. */ static struct fsnotify_group *audit_tree_group __ro_after_init;static struct kmem_cache *audit_tree_mark_cachep __ro_after_init; static struct audit_tree *alloc_tree(const char *s){ struct audit_tree *tree; tree = kmalloc(struct_size(tree, pathname, strlen(s) + 1), GFP_KERNEL); if (tree) { refcount_set(&tree->count, 1); tree->goner = 0; INIT_LIST_HEAD(&tree->chunks); INIT_LIST_HEAD(&tree->rules); INIT_LIST_HEAD(&tree->list); INIT_LIST_HEAD(&tree->same_root); tree->root = NULL; strcpy(tree->pathname, s); } return tree;} static inline void get_tree(struct audit_tree *tree){ refcount_inc(&tree->count);} static inline void put_tree(struct audit_tree *tree){ if (refcount_dec_and_test(&tree->count)) kfree_rcu(tree, head);} /* to avoid bringing the entire thing in audit.h */const char *audit_tree_path(struct audit_tree *tree){ return tree->pathname;} static void free_chunk(struct audit_chunk *chunk){ int i; for (i = 0; i < chunk->count; i++) { if (chunk->owners[i].owner) put_tree(chunk->owners[i].owner); } kfree(chunk);} void audit_put_chunk(struct audit_chunk *chunk){ if (atomic_long_dec_and_test(&chunk->refs)) free_chunk(chunk);} static void __put_chunk(struct rcu_head *rcu){ struct audit_chunk *chunk = container_of(rcu, struct audit_chunk, head); audit_put_chunk(chunk);} /* * Drop reference to the chunk that was held by the mark. This is the reference * that gets dropped after we've removed the chunk from the hash table and we * use it to make sure chunk cannot be freed before RCU grace period expires. */static void audit_mark_put_chunk(struct audit_chunk *chunk){ call_rcu(&chunk->head, __put_chunk);} static inline struct audit_tree_mark *audit_mark(struct fsnotify_mark *mark){ return container_of(mark, struct audit_tree_mark, mark);} static struct audit_chunk *mark_chunk(struct fsnotify_mark *mark){ return audit_mark(mark)->chunk;} static void audit_tree_destroy_watch(struct fsnotify_mark *mark){ kmem_cache_free(audit_tree_mark_cachep, audit_mark(mark));} static struct fsnotify_mark *alloc_mark(void){ struct audit_tree_mark *amark; amark = kmem_cache_zalloc(audit_tree_mark_cachep, GFP_KERNEL); if (!amark) return NULL; fsnotify_init_mark(&amark->mark, audit_tree_group); amark->mark.mask = FS_IN_IGNORED; return &amark->mark;} static struct audit_chunk *alloc_chunk(int count){ struct audit_chunk *chunk; int i; chunk = kzalloc(struct_size(chunk, owners, count), GFP_KERNEL); if (!chunk) return NULL; INIT_LIST_HEAD(&chunk->hash); INIT_LIST_HEAD(&chunk->trees); chunk->count = count; atomic_long_set(&chunk->refs, 1); for (i = 0; i < count; i++) { INIT_LIST_HEAD(&chunk->owners[i].list); chunk->owners[i].index = i; } return chunk;} enum {HASH_SIZE = 128};static struct list_head chunk_hash_heads[HASH_SIZE];static __cacheline_aligned_in_smp DEFINE_SPINLOCK(hash_lock); /* Function to return search key in our hash from inode. */static unsigned long inode_to_key(const struct inode *inode){ /* Use address pointed to by connector->obj as the key */ return (unsigned long)&inode->i_fsnotify_marks;} 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 & mark->group->mark_mutex is held by caller */static void insert_hash(struct audit_chunk *chunk){ struct list_head *list; /* * Make sure chunk is fully initialized before making it visible in the * hash. Pairs with a data dependency barrier in READ_ONCE() in * audit_tree_lookup(). */ smp_wmb(); WARN_ON_ONCE(!chunk->key); list = chunk_hash(chunk->key); list_add_rcu(&chunk->hash, list);} /* called under rcu_read_lock */struct audit_chunk *audit_tree_lookup(const struct inode *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) { /* * We use a data dependency barrier in READ_ONCE() to make sure * the chunk we see is fully initialized. */ if (READ_ONCE(p->key) == key) { atomic_long_inc(&p->refs); return p; } } return NULL;} bool audit_tree_match(struct audit_chunk *chunk, struct audit_tree *tree){ int n; for (n = 0; n < chunk->count; n++) if (chunk->owners[n].owner == tree) return true; return false;} /* tagging and untagging inodes with trees */ static struct audit_chunk *find_chunk(struct audit_node *p){ int index = p->index & ~(1U<<31); p -= index; return container_of(p, struct audit_chunk, owners[0]);} static void replace_mark_chunk(struct fsnotify_mark *mark, struct audit_chunk *chunk){ struct audit_chunk *old; assert_spin_locked(&hash_lock); old = mark_chunk(mark); audit_mark(mark)->chunk = chunk; if (chunk) chunk->mark = mark; if (old) old->mark = NULL;} static void replace_chunk(struct audit_chunk *new, struct audit_chunk *old){ struct audit_tree *owner; int i, j; new->key = old->key; list_splice_init(&old->trees, &new->trees); list_for_each_entry(owner, &new->trees, same_root) owner->root = new; for (i = j = 0; j < old->count; i++, j++) { if (!old->owners[j].owner) { i--; continue; } owner = old->owners[j].owner; new->owners[i].owner = owner; new->owners[i].index = old->owners[j].index - j + i; if (!owner) /* result of earlier fallback */ continue; get_tree(owner); list_replace_init(&old->owners[j].list, &new->owners[i].list); } replace_mark_chunk(old->mark, new); /* * Make sure chunk is fully initialized before making it visible in the * hash. Pairs with a data dependency barrier in READ_ONCE() in * audit_tree_lookup(). */ smp_wmb(); list_replace_rcu(&old->hash, &new->hash);} static void remove_chunk_node(struct audit_chunk *chunk, struct audit_node *p){ struct audit_tree *owner = p->owner; if (owner->root == chunk) { list_del_init(&owner->same_root); owner->root = NULL; } list_del_init(&p->list); p->owner = NULL; put_tree(owner);} static int chunk_count_trees(struct audit_chunk *chunk){ int i; int ret = 0; for (i = 0; i < chunk->count; i++) if (chunk->owners[i].owner) ret++; return ret;} static void untag_chunk(struct audit_chunk *chunk, struct fsnotify_mark *mark){ struct audit_chunk *new; int size; fsnotify_group_lock(audit_tree_group); /* * mark_mutex stabilizes chunk attached to the mark so we can check * whether it didn't change while we've dropped hash_lock. */ if (!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED) || mark_chunk(mark) != chunk) goto out_mutex; size = chunk_count_trees(chunk); if (!size) { spin_lock(&hash_lock); list_del_init(&chunk->trees); list_del_rcu(&chunk->hash); replace_mark_chunk(mark, NULL); spin_unlock(&hash_lock); fsnotify_detach_mark(mark); fsnotify_group_unlock(audit_tree_group); audit_mark_put_chunk(chunk); fsnotify_free_mark(mark); return; } new = alloc_chunk(size); if (!new) goto out_mutex; spin_lock(&hash_lock); /* * This has to go last when updating chunk as once replace_chunk() is * called, new RCU readers can see the new chunk. */ replace_chunk(new, chunk); spin_unlock(&hash_lock); fsnotify_group_unlock(audit_tree_group); audit_mark_put_chunk(chunk); return; out_mutex: fsnotify_group_unlock(audit_tree_group);} /* Call with group->mark_mutex held, releases it */static int create_chunk(struct inode *inode, struct audit_tree *tree){ struct fsnotify_mark *mark; struct audit_chunk *chunk = alloc_chunk(1); if (!chunk) { fsnotify_group_unlock(audit_tree_group); return -ENOMEM; } mark = alloc_mark(); if (!mark) { fsnotify_group_unlock(audit_tree_group); kfree(chunk); return -ENOMEM; } if (fsnotify_add_inode_mark_locked(mark, inode, 0)) { fsnotify_group_unlock(audit_tree_group); fsnotify_put_mark(mark); kfree(chunk); return -ENOSPC; } spin_lock(&hash_lock); if (tree->goner) { spin_unlock(&hash_lock); fsnotify_detach_mark(mark); fsnotify_group_unlock(audit_tree_group); fsnotify_free_mark(mark); fsnotify_put_mark(mark); kfree(chunk); return 0; } replace_mark_chunk(mark, chunk); chunk->owners[0].index = (1U << 31); chunk->owners[0].owner = tree; get_tree(tree); list_add(&chunk->owners[0].list, &tree->chunks); if (!tree->root) { tree->root = chunk; list_add(&tree->same_root, &chunk->trees); } chunk->key = inode_to_key(inode); /* * Inserting into the hash table has to go last as once we do that RCU * readers can see the chunk. */ insert_hash(chunk); spin_unlock(&hash_lock); fsnotify_group_unlock(audit_tree_group); /* * Drop our initial reference. When mark we point to is getting freed, * we get notification through ->freeing_mark callback and cleanup * chunk pointing to this mark. */ fsnotify_put_mark(mark); return 0;} /* the first tagged inode becomes root of tree */static int tag_chunk(struct inode *inode, struct audit_tree *tree){ struct fsnotify_mark *mark; struct audit_chunk *chunk, *old; struct audit_node *p; int n; fsnotify_group_lock(audit_tree_group); mark = fsnotify_find_inode_mark(inode, audit_tree_group); if (!mark) return create_chunk(inode, tree); /* * Found mark is guaranteed to be attached and mark_mutex protects mark * from getting detached and thus it makes sure there is chunk attached * to the mark. */ /* are we already there? */ spin_lock(&hash_lock); old = mark_chunk(mark); for (n = 0; n < old->count; n++) { if (old->owners[n].owner == tree) { spin_unlock(&hash_lock); fsnotify_group_unlock(audit_tree_group); fsnotify_put_mark(mark); return 0; } } spin_unlock(&hash_lock); chunk = alloc_chunk(old->count + 1); if (!chunk) { fsnotify_group_unlock(audit_tree_group); fsnotify_put_mark(mark); return -ENOMEM; } spin_lock(&hash_lock); if (tree->goner) { spin_unlock(&hash_lock); fsnotify_group_unlock(audit_tree_group); fsnotify_put_mark(mark); kfree(chunk);Lines 1–500 of 1086. Load more
// SPDX-License-Identifier: GPL-2.0 #include "audit.h" #include <linux/fsnotify_backend.h> #include <linux/namei.h> #include <linux/mount.h> #include <linux/kthread.h> #include <linux/refcount.h> #include <linux/slab.h> struct audit_tree; struct audit_chunk; struct audit_tree { refcount_t count; int goner; struct audit_chunk *root; struct list_head chunks; struct list_head rules; struct list_head list; struct list_head same_root; struct rcu_head head; char pathname[]; }; struct audit_chunk { struct list_head hash; unsigned long key; struct fsnotify_mark *mark; struct list_head trees; /* with root here */ int count; atomic_long_t refs; struct rcu_head head; struct audit_node { struct list_head list; struct audit_tree *owner; unsigned index; /* index; upper bit indicates 'will prune' */ } owners[] __counted_by(count); }; struct audit_tree_mark { struct fsnotify_mark mark; struct audit_chunk *chunk; }; static LIST_HEAD(tree_list); static LIST_HEAD(prune_list); static struct task_struct *prune_thread; /* * One struct chunk is attached to each inode of interest through * audit_tree_mark (fsnotify mark). We replace struct chunk on tagging / * untagging, the mark is stable as long as there is chunk attached. The * association between mark and chunk is protected by hash_lock and * audit_tree_group->mark_mutex. Thus as long as we hold * audit_tree_group->mark_mutex and check that the mark is alive by * FSNOTIFY_MARK_FLAG_ATTACHED flag check, we are sure the mark points to * the current chunk. * * Rules have pointer to struct audit_tree. * Rules have struct list_head rlist forming a list of rules over * the same tree. * References to struct chunk are collected at audit_inode{,_child}() * time and used in AUDIT_TREE rule matching. * These references are dropped at the same time we are calling * audit_free_names(), etc. * * Cyclic lists galore: * tree.chunks anchors chunk.owners[].list hash_lock * tree.rules anchors rule.rlist audit_filter_mutex * chunk.trees anchors tree.same_root hash_lock * chunk.hash is a hash with middle bits of watch.inode as * a hash function. RCU, hash_lock * * tree is refcounted; one reference for "some rules on rules_list refer to * it", one for each chunk with pointer to it. * * chunk is refcounted by embedded .refs. Mark associated with the chunk holds * one chunk reference. This reference is dropped either when a mark is going * to be freed (corresponding inode goes away) or when chunk attached to the * mark gets replaced. This reference must be dropped using * audit_mark_put_chunk() to make sure the reference is dropped only after RCU * grace period as it protects RCU readers of the hash table. * * node.index allows to get from node.list to containing chunk. * MSB of that sucker is stolen to mark taggings that we might have to * revert - several operations have very unpleasant cleanup logics and * that makes a difference. Some. */ static struct fsnotify_group *audit_tree_group __ro_after_init; static struct kmem_cache *audit_tree_mark_cachep __ro_after_init; static struct audit_tree *alloc_tree(const char *s) { struct audit_tree *tree; tree = kmalloc(struct_size(tree, pathname, strlen(s) + 1), GFP_KERNEL); if (tree) { refcount_set(&tree->count, 1); tree->goner = 0; INIT_LIST_HEAD(&tree->chunks); INIT_LIST_HEAD(&tree->rules); INIT_LIST_HEAD(&tree->list); INIT_LIST_HEAD(&tree->same_root); tree->root = NULL; strcpy(tree->pathname, s); } return tree; } static inline void get_tree(struct audit_tree *tree) { refcount_inc(&tree->count); } static inline void put_tree(struct audit_tree *tree) { if (refcount_dec_and_test(&tree->count)) kfree_rcu(tree, head); } /* to avoid bringing the entire thing in audit.h */ const char *audit_tree_path(struct audit_tree *tree) { return tree->pathname; } static void free_chunk(struct audit_chunk *chunk) { int i; for (i = 0; i < chunk->count; i++) { if (chunk->owners[i].owner) put_tree(chunk->owners[i].owner); } kfree(chunk); } void audit_put_chunk(struct audit_chunk *chunk) { if (atomic_long_dec_and_test(&chunk->refs)) free_chunk(chunk); } static void __put_chunk(struct rcu_head *rcu) { struct audit_chunk *chunk = container_of(rcu, struct audit_chunk, head); audit_put_chunk(chunk); } /* * Drop reference to the chunk that was held by the mark. This is the reference * that gets dropped after we've removed the chunk from the hash table and we * use it to make sure chunk cannot be freed before RCU grace period expires. */ static void audit_mark_put_chunk(struct audit_chunk *chunk) { call_rcu(&chunk->head, __put_chunk); } static inline struct audit_tree_mark *audit_mark(struct fsnotify_mark *mark) { return container_of(mark, struct audit_tree_mark, mark); } static struct audit_chunk *mark_chunk(struct fsnotify_mark *mark) { return audit_mark(mark)->chunk; } static void audit_tree_destroy_watch(struct fsnotify_mark *mark) { kmem_cache_free(audit_tree_mark_cachep, audit_mark(mark)); } static struct fsnotify_mark *alloc_mark(void) { struct audit_tree_mark *amark; amark = kmem_cache_zalloc(audit_tree_mark_cachep, GFP_KERNEL); if (!amark) return NULL; fsnotify_init_mark(&amark->mark, audit_tree_group); amark->mark.mask = FS_IN_IGNORED; return &amark->mark; } static struct audit_chunk *alloc_chunk(int count) { struct audit_chunk *chunk; int i; chunk = kzalloc(struct_size(chunk, owners, count), GFP_KERNEL); if (!chunk) return NULL; INIT_LIST_HEAD(&chunk->hash); INIT_LIST_HEAD(&chunk->trees); chunk->count = count; atomic_long_set(&chunk->refs, 1); for (i = 0; i < count; i++) { INIT_LIST_HEAD(&chunk->owners[i].list); chunk->owners[i].index = i; } return chunk; } enum {HASH_SIZE = 128}; static struct list_head chunk_hash_heads[HASH_SIZE]; static __cacheline_aligned_in_smp DEFINE_SPINLOCK(hash_lock); /* Function to return search key in our hash from inode. */ static unsigned long inode_to_key(const struct inode *inode) { /* Use address pointed to by connector->obj as the key */ return (unsigned long)&inode->i_fsnotify_marks; } 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 & mark->group->mark_mutex is held by caller */ static void insert_hash(struct audit_chunk *chunk) { struct list_head *list; /* * Make sure chunk is fully initialized before making it visible in the * hash. Pairs with a data dependency barrier in READ_ONCE() in * audit_tree_lookup(). */ smp_wmb(); WARN_ON_ONCE(!chunk->key); list = chunk_hash(chunk->key); list_add_rcu(&chunk->hash, list); } /* called under rcu_read_lock */ struct audit_chunk *audit_tree_lookup(const struct inode *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) { /* * We use a data dependency barrier in READ_ONCE() to make sure * the chunk we see is fully initialized. */ if (READ_ONCE(p->key) == key) { atomic_long_inc(&p->refs); return p; } } return NULL; } bool audit_tree_match(struct audit_chunk *chunk, struct audit_tree *tree) { int n; for (n = 0; n < chunk->count; n++) if (chunk->owners[n].owner == tree) return true; return false; } /* tagging and untagging inodes with trees */ static struct audit_chunk *find_chunk(struct audit_node *p) { int index = p->index & ~(1U<<31); p -= index; return container_of(p, struct audit_chunk, owners[0]); } static void replace_mark_chunk(struct fsnotify_mark *mark, struct audit_chunk *chunk) { struct audit_chunk *old; assert_spin_locked(&hash_lock); old = mark_chunk(mark); audit_mark(mark)->chunk = chunk; if (chunk) chunk->mark = mark; if (old) old->mark = NULL; } static void replace_chunk(struct audit_chunk *new, struct audit_chunk *old) { struct audit_tree *owner; int i, j; new->key = old->key; list_splice_init(&old->trees, &new->trees); list_for_each_entry(owner, &new->trees, same_root) owner->root = new; for (i = j = 0; j < old->count; i++, j++) { if (!old->owners[j].owner) { i--; continue; } owner = old->owners[j].owner; new->owners[i].owner = owner; new->owners[i].index = old->owners[j].index - j + i; if (!owner) /* result of earlier fallback */ continue; get_tree(owner); list_replace_init(&old->owners[j].list, &new->owners[i].list); } replace_mark_chunk(old->mark, new); /* * Make sure chunk is fully initialized before making it visible in the * hash. Pairs with a data dependency barrier in READ_ONCE() in * audit_tree_lookup(). */ smp_wmb(); list_replace_rcu(&old->hash, &new->hash); } static void remove_chunk_node(struct audit_chunk *chunk, struct audit_node *p) { struct audit_tree *owner = p->owner; if (owner->root == chunk) { list_del_init(&owner->same_root); owner->root = NULL; } list_del_init(&p->list); p->owner = NULL; put_tree(owner); } static int chunk_count_trees(struct audit_chunk *chunk) { int i; int ret = 0; for (i = 0; i < chunk->count; i++) if (chunk->owners[i].owner) ret++; return ret; } static void untag_chunk(struct audit_chunk *chunk, struct fsnotify_mark *mark) { struct audit_chunk *new; int size; fsnotify_group_lock(audit_tree_group); /* * mark_mutex stabilizes chunk attached to the mark so we can check * whether it didn't change while we've dropped hash_lock. */ if (!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED) || mark_chunk(mark) != chunk) goto out_mutex; size = chunk_count_trees(chunk); if (!size) { spin_lock(&hash_lock); list_del_init(&chunk->trees); list_del_rcu(&chunk->hash); replace_mark_chunk(mark, NULL); spin_unlock(&hash_lock); fsnotify_detach_mark(mark); fsnotify_group_unlock(audit_tree_group); audit_mark_put_chunk(chunk); fsnotify_free_mark(mark); return; } new = alloc_chunk(size); if (!new) goto out_mutex; spin_lock(&hash_lock); /* * This has to go last when updating chunk as once replace_chunk() is * called, new RCU readers can see the new chunk. */ replace_chunk(new, chunk); spin_unlock(&hash_lock); fsnotify_group_unlock(audit_tree_group); audit_mark_put_chunk(chunk); return; out_mutex: fsnotify_group_unlock(audit_tree_group); } /* Call with group->mark_mutex held, releases it */ static int create_chunk(struct inode *inode, struct audit_tree *tree) { struct fsnotify_mark *mark; struct audit_chunk *chunk = alloc_chunk(1); if (!chunk) { fsnotify_group_unlock(audit_tree_group); return -ENOMEM; } mark = alloc_mark(); if (!mark) { fsnotify_group_unlock(audit_tree_group); kfree(chunk); return -ENOMEM; } if (fsnotify_add_inode_mark_locked(mark, inode, 0)) { fsnotify_group_unlock(audit_tree_group); fsnotify_put_mark(mark); kfree(chunk); return -ENOSPC; } spin_lock(&hash_lock); if (tree->goner) { spin_unlock(&hash_lock); fsnotify_detach_mark(mark); fsnotify_group_unlock(audit_tree_group); fsnotify_free_mark(mark); fsnotify_put_mark(mark); kfree(chunk); return 0; } replace_mark_chunk(mark, chunk); chunk->owners[0].index = (1U << 31); chunk->owners[0].owner = tree; get_tree(tree); list_add(&chunk->owners[0].list, &tree->chunks); if (!tree->root) { tree->root = chunk; list_add(&tree->same_root, &chunk->trees); } chunk->key = inode_to_key(inode); /* * Inserting into the hash table has to go last as once we do that RCU * readers can see the chunk. */ insert_hash(chunk); spin_unlock(&hash_lock); fsnotify_group_unlock(audit_tree_group); /* * Drop our initial reference. When mark we point to is getting freed, * we get notification through ->freeing_mark callback and cleanup * chunk pointing to this mark. */ fsnotify_put_mark(mark); return 0; } /* the first tagged inode becomes root of tree */ static int tag_chunk(struct inode *inode, struct audit_tree *tree) { struct fsnotify_mark *mark; struct audit_chunk *chunk, *old; struct audit_node *p; int n; fsnotify_group_lock(audit_tree_group); mark = fsnotify_find_inode_mark(inode, audit_tree_group); if (!mark) return create_chunk(inode, tree); /* * Found mark is guaranteed to be attached and mark_mutex protects mark * from getting detached and thus it makes sure there is chunk attached * to the mark. */ /* are we already there? */ spin_lock(&hash_lock); old = mark_chunk(mark); for (n = 0; n < old->count; n++) { if (old->owners[n].owner == tree) { spin_unlock(&hash_lock); fsnotify_group_unlock(audit_tree_group); fsnotify_put_mark(mark); return 0; } } spin_unlock(&hash_lock); chunk = alloc_chunk(old->count + 1); if (!chunk) { fsnotify_group_unlock(audit_tree_group); fsnotify_put_mark(mark); return -ENOMEM; } spin_lock(&hash_lock); if (tree->goner) { spin_unlock(&hash_lock); fsnotify_group_unlock(audit_tree_group); fsnotify_put_mark(mark); kfree(chunk);