cregit-Linux how code gets into the kernel

Release 4.15 kernel/audit_tree.c

Directory: kernel
// 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;
	
struct fsnotify_mark mark;
	
struct list_head trees;		/* with root here */
	
int dead;
	
int count;
	
atomic_long_t refs;
	
struct rcu_head head;
	
struct node {
		
struct list_head list;
		
struct audit_tree *owner;
		
unsigned index;		/* index; upper bit indicates 'will prune' */
	
} owners[];
};

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.
 * We replace struct chunk on tagging/untagging.
 * 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 fsnotify_mark + .refs (non-zero refcount
 * of watch contributes 1 to .refs).
 *
 * 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;


static struct audit_tree *alloc_tree(const char *s) { struct audit_tree *tree; tree = kmalloc(sizeof(struct audit_tree) + 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; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro10999.09%150.00%
Elena Reshetova10.91%150.00%
Total110100.00%2100.00%


static inline void get_tree(struct audit_tree *tree) { refcount_inc(&tree->count); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro1995.00%150.00%
Elena Reshetova15.00%150.00%
Total20100.00%2100.00%


static inline void put_tree(struct audit_tree *tree) { if (refcount_dec_and_test(&tree->count)) kfree_rcu(tree, head); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro2689.66%133.33%
Lai Jiangshan26.90%133.33%
Elena Reshetova13.45%133.33%
Total29100.00%3100.00%

/* to avoid bringing the entire thing in audit.h */
const char *audit_tree_path(struct audit_tree *tree) { return tree->pathname; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro17100.00%1100.00%
Total17100.00%1100.00%


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); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro59100.00%2100.00%
Total59100.00%2100.00%


void audit_put_chunk(struct audit_chunk *chunk) { if (atomic_long_dec_and_test(&chunk->refs)) free_chunk(chunk); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro25100.00%2100.00%
Total25100.00%2100.00%


static void __put_chunk(struct rcu_head *rcu) { struct audit_chunk *chunk = container_of(rcu, struct audit_chunk, head); audit_put_chunk(chunk); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro2477.42%266.67%
Eric Paris722.58%133.33%
Total31100.00%3100.00%


static void audit_tree_destroy_watch(struct fsnotify_mark *entry) { struct audit_chunk *chunk = container_of(entry, struct audit_chunk, mark); call_rcu(&chunk->head, __put_chunk); }

Contributors

PersonTokensPropCommitsCommitProp
Eric Paris36100.00%2100.00%
Total36100.00%2100.00%


static struct audit_chunk *alloc_chunk(int count) { struct audit_chunk *chunk; size_t size; int i; size = offsetof(struct audit_chunk, owners) + count * sizeof(struct node); chunk = kzalloc(size, 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; } fsnotify_init_mark(&chunk->mark, audit_tree_group); chunk->mark.mask = FS_IN_IGNORED; return chunk; }

Contributors

PersonTokensPropCommitsCommitProp
Eric Paris13590.60%125.00%
Miklos Szeredi85.37%125.00%
Al Viro53.36%125.00%
Jan Kara10.67%125.00%
Total149100.00%4100.00%

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) { return (unsigned long)inode; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro1155.00%150.00%
Jan Kara945.00%150.00%
Total20100.00%2100.00%

/* * 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; }

Contributors

PersonTokensPropCommitsCommitProp
Jan Kara3687.80%375.00%
Al Viro512.20%125.00%
Total41100.00%4100.00%


static inline struct list_head *chunk_hash(unsigned long key) { unsigned long n = key / L1_CACHE_BYTES; return chunk_hash_heads + n % HASH_SIZE; }

Contributors

PersonTokensPropCommitsCommitProp
Jan Kara1760.71%150.00%
Al Viro1139.29%150.00%
Total28100.00%2100.00%

/* hash_lock & entry->lock is held by caller */
static void insert_hash(struct audit_chunk *chunk) { unsigned long key = chunk_to_key(chunk); struct list_head *list; if (!(chunk->mark.flags & FSNOTIFY_MARK_FLAG_ATTACHED)) return; list = chunk_hash(key); list_add_rcu(&chunk->hash, list); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro2748.21%120.00%
Jan Kara1526.79%360.00%
Eric Paris1425.00%120.00%
Total56100.00%5100.00%

/* 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) { if (chunk_to_key(p) == key) { atomic_long_inc(&p->refs); return p; } } return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro5272.22%250.00%
Jan Kara1419.44%125.00%
Paul E. McKenney68.33%125.00%
Total72100.00%4100.00%


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; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro4994.23%150.00%
Yaowei Bai35.77%150.00%
Total52100.00%2100.00%

/* tagging and untagging inodes with trees */
static struct audit_chunk *find_chunk(struct node *p) { int index = p->index & ~(1U<<31); p -= index; return container_of(p, struct audit_chunk, owners[0]); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro45100.00%1100.00%
Total45100.00%1100.00%


static void untag_chunk(struct node *p) { struct audit_chunk *chunk = find_chunk(p); struct fsnotify_mark *entry = &chunk->mark; struct audit_chunk *new = NULL; struct audit_tree *owner; int size = chunk->count - 1; int i, j; fsnotify_get_mark(entry); spin_unlock(&hash_lock); if (size) new = alloc_chunk(size); mutex_lock(&entry->group->mark_mutex); spin_lock(&entry->lock); /* * 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) fsnotify_put_mark(&new->mark); goto out; } owner = p->owner; if (!size) { chunk->dead = 1; spin_lock(&hash_lock); list_del_init(&chunk->trees); if (owner->root == chunk) owner->root = NULL; list_del_init(&p->list); list_del_rcu(&chunk->hash); spin_unlock(&hash_lock); spin_unlock(&entry->lock); mutex_unlock(&entry->group->mark_mutex); fsnotify_destroy_mark(entry, audit_tree_group); goto out; } if (!new) goto Fallback; if (fsnotify_add_mark_locked(&new->mark, entry->connector->inode, NULL, 1)) { fsnotify_put_mark(&new->mark); goto Fallback; } chunk->dead = 1; spin_lock(&hash_lock); list_replace_init(&chunk->trees, &new->trees); if (owner->root == chunk) { list_del_init(&owner->same_root); owner->root = NULL; } for (i = j = 0; j <= size; i++, j++) { struct audit_tree *s; if (&chunk->owners[j] == p) { list_del_init(&p->list); i--; continue; } s = chunk->owners[j].owner; new->owners[i].owner = s; new->owners[i].index = chunk->owners[j].index - j + i; if (!s) /* result of earlier fallback */ continue; get_tree(s); list_replace_init(&chunk->owners[j].list, &new->owners[i].list); } list_replace_rcu(&chunk->hash, &new->hash); list_for_each_entry(owner, &new->trees, same_root) owner->root = new; spin_unlock(&hash_lock); spin_unlock(&entry->lock); mutex_unlock(&entry->group->mark_mutex); fsnotify_destroy_mark(entry, audit_tree_group); fsnotify_put_mark(&new->mark); /* drop initial reference */ goto out; Fallback: // do the best we can spin_lock(&hash_lock); if (owner->root == chunk) { list_del_init(&owner->same_root); owner->root = NULL; } list_del_init(&p->list); p->owner = NULL; put_tree(owner); spin_unlock(&hash_lock); spin_unlock(&entry->lock); mutex_unlock(&entry->group->mark_mutex); out: fsnotify_put_mark(entry); spin_lock(&hash_lock); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro49979.97%423.53%
Jan Kara6310.10%635.29%
Eric Paris457.21%423.53%
Miklos Szeredi132.08%211.76%
Lino Sanfilippo40.64%15.88%
Total624100.00%17100.00%


static int create_chunk(struct inode *inode, struct audit_tree *tree) { struct fsnotify_mark *entry; struct audit_chunk *chunk = alloc_chunk(1); if (!chunk) return -ENOMEM; entry = &chunk->mark; if (fsnotify_add_mark(entry, inode, NULL, 0)) { fsnotify_put_mark(entry); return -ENOSPC; } spin_lock(&entry->lock); spin_lock(&hash_lock); if (tree->goner) { spin_unlock(&hash_lock); chunk->dead = 1; spin_unlock(&entry->lock); fsnotify_destroy_mark(entry, audit_tree_group); fsnotify_put_mark(entry); return 0; } 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); } insert_hash(chunk); spin_unlock(&hash_lock); spin_unlock(&entry->lock); fsnotify_put_mark(entry); /* drop initial reference */ return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro19081.55%112.50%
Eric Paris3314.16%450.00%
Miklos Szeredi83.43%225.00%
Lino Sanfilippo20.86%112.50%
Total233100.00%8100.00%

/* the first tagged inode becomes root of tree */
static int tag_chunk(struct inode *inode, struct audit_tree *tree) { struct fsnotify_mark *old_entry, *chunk_entry; struct audit_tree *owner; struct audit_chunk *chunk, *old; struct node *p; int n; old_entry = fsnotify_find_mark(&inode->i_fsnotify_marks, audit_tree_group); if (!old_entry) return create_chunk(inode, tree); old = container_of(old_entry, struct audit_chunk, mark); /* are we already there? */ spin_lock(&hash_lock); for (n = 0; n < old->count; n++) { if (old->owners[n].owner == tree) { spin_unlock(&hash_lock); fsnotify_put_mark(old_entry); return 0; } } spin_unlock(&hash_lock); chunk = alloc_chunk(old->count + 1); if (!chunk) { fsnotify_put_mark(old_entry); return -ENOMEM; } chunk_entry = &chunk->mark; mutex_lock(&old_entry->group->mark_mutex); spin_lock(&old_entry->lock); /* * 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); fsnotify_put_mark(&chunk->mark); return -ENOENT; } 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); fsnotify_put_mark(old_entry); return -ENOSPC; } /* even though we hold old_entry->lock, this is safe since chunk_entry->lock could NEVER have been grabbed before */ spin_lock(&chunk_entry->lock); spin_lock(&hash_lock); /* we now hold old_entry->lock, chunk_entry->lock, and hash_lock */ if (tree->goner) { spin_unlock(&hash_lock); chunk->dead = 1; spin_unlock(&chunk_entry->lock); spin_unlock(&old_entry->lock); mutex_unlock(&old_entry->group->mark_mutex); fsnotify_destroy_mark(chunk_entry, audit_tree_group); fsnotify_put_mark(chunk_entry); fsnotify_put_mark(old_entry); return 0; } list_replace_init(&old->trees, &chunk->trees); for (n = 0, p = chunk->owners; n < old->count; n++, p++) { struct audit_tree *s = old->owners[n].owner; p->owner = s; p->index = old->owners[n].index; if (!s) /* result of fallback in untag */ continue; get_tree(s); list_replace_init(&old->owners[n].list, &p->list); } p->index = (chunk->count - 1) | (1U<<31); p->owner = tree; get_tree(tree); list_add(&p->list, &tree->chunks); list_replace_rcu(&old->hash, &chunk->hash); list_for_each_entry(owner, &chunk->trees, same_root) owner->root = chunk; old->dead = 1; if (!tree->root) { tree->root = chunk; list_add(&tree->same_root, &chunk->trees); } spin_unlock(&hash_lock); spin_unlock(&chunk_entry->lock); spin_unlock(&old_entry->lock); mutex_unlock(&old_entry->group->mark_mutex); fsnotify_destroy_mark(old_entry, audit_tree_group); fsnotify_put_mark(chunk_entry); /* drop initial reference */ fsnotify_put_mark(old_entry); /* pair to fsnotify_find mark_entry */ return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro43969.13%211.76%
Eric Paris11518.11%529.41%
Jan Kara6910.87%741.18%
Miklos Szeredi81.26%211.76%
Lino Sanfilippo40.63%15.88%
Total635100.00%17100.00%


static void audit_tree_log_remove_rule(struct audit_krule *rule) { struct audit_buffer *ab; ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE); if (unlikely(!ab)) return; audit_log_format(ab, "op=remove_rule"); audit_log_format(ab, " dir="); audit_log_untrustedstring(ab, rule->tree->pathname); audit_log_key(ab, rule->filterkey); audit_log_format(ab, " list=%d res=1", rule->listnr); audit_log_end(ab); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro6474.42%120.00%
Kees Cook1213.95%120.00%
Eric Paris89.30%120.00%
Steve Grubb11.16%120.00%
Richard Guy Briggs11.16%120.00%
Total86100.00%5100.00%


static void kill_rules(struct audit_tree *tree) { struct audit_krule *rule, *next; struct audit_entry *entry; list_for_each_entry_safe(rule, next, &tree->rules, rlist) { entry = container_of(rule, struct audit_entry, rule); list_del_init(&rule->rlist); if (rule->tree) { /* not a half-baked one */ audit_tree_log_remove_rule(rule); if (entry->rule.exe) audit_remove_mark(entry->rule.exe); rule->tree = NULL; list_del_rcu(&entry->list); list_del(&entry->rule.list); call_rcu(&entry->rcu, audit_free_rule_rcu); } } }

Contributors

PersonTokensPropCommitsCommitProp
Kees Cook6654.55%120.00%
Al Viro3730.58%240.00%
Richard Guy Briggs1814.88%240.00%
Total121100.00%5100.00%

/* * finish killing struct audit_tree */
static void prune_one(struct audit_tree *victim) { spin_lock(&hash_lock); while (!list_empty(&victim->chunks)) { struct node *p; p = list_entry(victim->chunks.next, struct node, list); untag_chunk(p); } spin_unlock(&hash_lock); put_tree(victim); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro67100.00%1100.00%
Total67100.00%1100.00%

/* trim the uncommitted chunks from tree */
static void trim_marked(struct audit_tree *tree) { struct list_head *p, *q; spin_lock(&hash_lock); if (tree->goner) { spin_unlock(&hash_lock); return; } /* reorder */ for (p = tree->chunks.next; p != &tree->chunks; p = q) { struct node *node = list_entry(p, struct node, list); q = p->next; if (node->index & (1U<<31)) { list_del_init(p); list_add(p, &tree->chunks); } } while (!list_empty(&tree->chunks)) { struct node *node; node = list_entry(tree->chunks.next, struct node, list); /* have we run out of marked? */ if (!(node->index & (1U<<31))) break; untag_chunk(node); } if (!tree->root && !tree->goner) { tree->goner = 1; spin_unlock(&hash_lock); mutex_lock(&audit_filter_mutex); kill_rules(tree); list_del_init(&tree->list); mutex_unlock(&audit_filter_mutex); prune_one(tree); } else { spin_unlock(&hash_lock); } }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro235100.00%1100.00%
Total235100.00%1100.00%

static void audit_schedule_prune(void); /* called with audit_filter_mutex */
int audit_remove_tree_rule(struct audit_krule *rule) { struct audit_tree *tree; tree = rule->tree; if (tree) { spin_lock(&hash_lock); list_del_init(&rule->rlist); if (list_empty(&tree->rules) && !tree->goner) { tree->root = NULL; list_del_init(&tree->same_root); tree->goner = 1; list_move(&tree->list, &prune_list); rule->tree = NULL; spin_unlock(&hash_lock); audit_schedule_prune(); return 1; } rule->tree = NULL; spin_unlock(&hash_lock); return 1; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro125100.00%1100.00%
Total125100.00%1100.00%


static int compare_root(struct vfsmount *mnt, void *arg) { return inode_to_key(d_backing_inode(mnt->mnt_root)) == (unsigned long)arg; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro2268.75%133.33%
Jan Kara721.88%133.33%
David Howells39.38%133.33%
Total32100.00%3100.00%


void audit_trim_trees(void) { struct list_head cursor; mutex_lock(&audit_filter_mutex); list_add(&cursor, &tree_list); while (cursor.next != &tree_list) { struct audit_tree *tree; struct path path; struct vfsmount *root_mnt; struct node *node; int err; tree = container_of(cursor.next, struct audit_tree, list); get_tree(tree); list_del(&cursor); list_add(&cursor, &tree->list); mutex_unlock(&audit_filter_mutex); err = kern_path(tree->pathname, 0, &path); if (err) goto skip_it; root_mnt = collect_mounts(&path); path_put(&path); if (IS_ERR(root_mnt)) goto skip_it; spin_lock(&hash_lock); 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... */ node->index |= 1U<<31; if (iterate_mounts(compare_root, (void *)chunk_to_key(chunk), root_mnt)) node->index &= ~(1U<<31); } spin_unlock(&hash_lock); trim_marked(tree); drop_collected_mounts(root_mnt); skip_it: put_tree(tree); mutex_lock(&audit_filter_mutex); } list_del(&cursor); mutex_unlock(&audit_filter_mutex); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro22890.84%436.36%
Jan Kara83.19%19.09%
Chen Gang S51.99%19.09%
Eric Paris31.20%19.09%
David Howells31.20%19.09%
Jan Blunck31.20%218.18%
Lucas De Marchi10.40%19.09%
Total251100.00%11100.00%


int audit_make_tree(struct audit_krule *rule, char *pathname, u32 op) { if (pathname[0] != '/' || rule->listnr != AUDIT_FILTER_EXIT || op != Audit_equal || rule->inode_f || rule->watch || rule->tree) return -EINVAL; rule->tree = alloc_tree(pathname); if (!rule->tree) return -ENOMEM; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro75100.00%2100.00%
Total75100.00%2100.00%


void audit_put_tree(struct audit_tree *tree) { put_tree(tree); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro15100.00%1100.00%
Total15100.00%1100.00%


static int tag_mount(struct vfsmount *mnt, void *arg) { return tag_chunk(d_backing_inode(mnt->mnt_root), arg); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro2589.29%150.00%
David Howells310.71%150.00%
Total28100.00%2100.00%

/* * That gets run when evict_chunk() ends up needing to kill audit_tree. * Runs from a separate thread. */
static int prune_tree_thread(void *unused) { for (;;) { if (list_empty(&prune_list)) { set_current_state(TASK_INTERRUPTIBLE); schedule(); } mutex_lock(&audit_cmd_mutex); mutex_lock(&audit_filter_mutex); while (!list_empty(&prune_list)) { struct audit_tree *victim; victim = list_entry(prune_list.next, struct audit_tree, list); list_del_init(&victim->list); mutex_unlock(&audit_filter_mutex); prune_one(victim); mutex_lock(&audit_filter_mutex); } mutex_unlock(&audit_filter_mutex); mutex_unlock(&audit_cmd_mutex); } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Imre Palik11094.02%150.00%
Jiri Slaby75.98%150.00%
Total117100.00%2100.00%


static int audit_launch_prune(void) { if (prune_thread) return 0; prune_thread = kthread_run(prune_tree_thread, NULL, "audit_prune_tree"); if (IS_ERR(prune_thread)) { pr_err("cannot start thread audit_prune_tree"); prune_thread = NULL; return -ENOMEM; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Imre Palik5098.04%150.00%
Jiri Slaby11.96%150.00%
Total51100.00%2100.00%

/* called with audit_filter_mutex */
int audit_add_tree_rule(struct audit_krule *rule) { struct audit_tree *seed = rule->tree, *tree; struct path path; struct vfsmount *mnt; int err; rule->tree = NULL; list_for_each_entry(tree, &tree_list, list) { if (!strcmp(seed->pathname, tree->pathname)) { put_tree(seed); rule->tree = tree; list_add(&rule->rlist, &tree->rules); return 0; } } tree = seed; list_add(&tree->list, &tree_list); list_add(&rule->rlist, &tree->rules); /* do not set rule->tree yet */ mutex_unlock(&audit_filter_mutex); if (unlikely(!prune_thread)) { err = audit_launch_prune(); if (err) goto Err; } err = kern_path(tree->pathname, 0, &path); if (err) goto Err; mnt = collect_mounts(&path); path_put(&path); if (IS_ERR(mnt)) { err = PTR_ERR(mnt); goto Err; } get_tree(tree); err = iterate_mounts(tag_mount, tree, mnt); drop_collected_mounts(mnt); if (!err) { struct node *node; spin_lock(&hash_lock); list_for_each_entry(node, &tree->chunks, list) node->index &= ~(1U<<31); spin_unlock(&hash_lock); } else { trim_marked(tree); goto Err; } mutex_lock(&audit_filter_mutex); if (list_empty(&rule->rlist)) { put_tree(tree); return -ENOENT; } rule->tree = tree; put_tree(tree); return 0; Err: mutex_lock(&audit_filter_mutex); list_del_init(&tree->list); list_del_init(&tree->rules); put_tree(tree); return err; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro31489.20%444.44%
Imre Palik226.25%111.11%
David Howells71.99%111.11%
Chen Gang S61.70%111.11%
Jan Blunck30.85%222.22%
Total352100.00%9100.00%


int audit_tag_tree(char *old, char *new) { struct list_head cursor, barrier; int failed = 0; struct path path1, path2; struct vfsmount *tagged; int err; err = kern_path(new, 0, &path2); if (err) return err; tagged = collect_mounts(&path2); path_put(&path2); if (IS_ERR(tagged)) return PTR_ERR(tagged); err = kern_path(old, 0, &path1); if (err) { drop_collected_mounts(tagged); return err; } mutex_lock(&audit_filter_mutex); list_add(&barrier, &tree_list); list_add(&cursor, &barrier); while (cursor.next != &tree_list) { struct audit_tree *tree; int good_one = 0; tree = container_of(cursor.next, struct audit_tree, list); get_tree(tree); list_del(&cursor); list_add(&cursor, &tree->list); mutex_unlock(&audit_filter_mutex); err = kern_path(tree->pathname, 0, &path2); if (!err) { good_one = path_is_under(&path1, &path2); path_put(&path2); } if (!good_one) { put_tree(tree); mutex_lock(&audit_filter_mutex); continue; } failed = iterate_mounts(tag_mount, tree, tagged); if (failed) { put_tree(tree); mutex_lock(&audit_filter_mutex); break; } mutex_lock(&audit_filter_mutex); spin_lock(&hash_lock); if (!tree->goner) { list_del(&tree->list); list_add(&tree->list, &tree_list); } spin_unlock(&hash_lock); put_tree(tree); } while (barrier.prev != &tree_list) { struct audit_tree *tree; tree = container_of(barrier.prev, struct audit_tree, list); get_tree(tree); list_del(&tree->list); list_add(&tree->list, &barrier); mutex_unlock(&audit_filter_mutex); if (!failed) { struct node *node; spin_lock(&hash_lock); list_for_each_entry(node, &tree->chunks, list) node->index &= ~(1U<<31); spin_unlock(&hash_lock); } else { trim_marked(tree); } put_tree(tree); mutex_lock(&audit_filter_mutex); } list_del(&barrier); list_del(&cursor); mutex_unlock(&audit_filter_mutex); path_put(&path1); drop_collected_mounts(tagged); return failed; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro48098.36%571.43%
David Howells71.43%114.29%
Jan Blunck10.20%114.29%
Total488100.00%7100.00%


static void audit_schedule_prune(void) { wake_up_process(prune_thread); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro1184.62%150.00%
Imre Palik215.38%150.00%
Total13100.00%2100.00%

/* * ... and that one is done if evict_chunk() decides to delay until the end * of syscall. Runs synchronously. */
void audit_kill_trees(struct list_head *list) { mutex_lock(&audit_cmd_mutex); mutex_lock(&audit_filter_mutex); while (!list_empty(list)) { struct audit_tree *victim; victim = list_entry(list->next, struct audit_tree, list); kill_rules(victim); list_del_init(&victim->list); mutex_unlock(&audit_filter_mutex); prune_one(victim); mutex_lock(&audit_filter_mutex); } mutex_unlock(&audit_filter_mutex); mutex_unlock(&audit_cmd_mutex); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro93100.00%2100.00%
Total93100.00%2100.00%

/* * Here comes the stuff asynchronous to auditctl operations */
static void evict_chunk(struct audit_chunk *chunk) { struct audit_tree *owner; struct list_head *postponed = audit_killed_trees(); int need_prune = 0; int n; if (chunk->dead) return; chunk->dead = 1; mutex_lock(&audit_filter_mutex); spin_lock(&hash_lock); while (!list_empty(&chunk->trees)) { owner = list_entry(chunk->trees.next, struct audit_tree, same_root); owner->goner = 1; owner->root = NULL; list_del_init(&owner->same_root); spin_unlock(&hash_lock); if (!postponed) { kill_rules(owner); list_move(&owner->list, &prune_list); need_prune = 1; } else { list_move(&owner->list, postponed); } spin_lock(&hash_lock); } list_del_rcu(&chunk->hash); for (n = 0; n < chunk->count; n++) list_del_init(&chunk->owners[n].list); spin_unlock(&hash_lock); mutex_unlock(&audit_filter_mutex); if (need_prune) audit_schedule_prune(); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro20797.18%266.67%
Imre Palik62.82%133.33%
Total213100.00%3100.00%


static int audit_tree_handle_event(struct fsnotify_group *group, struct inode *to_tell, 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, struct fsnotify_iter_info *iter_info) { return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Jan Kara2953.70%444.44%
Eric Paris1935.19%333.33%
Al Viro611.11%222.22%
Total54100.00%9100.00%


static void audit_tree_freeing_mark(struct fsnotify_mark *entry, struct fsnotify_group *group) { struct audit_chunk *chunk = container_of(entry, struct audit_chunk, mark); evict_chunk(chunk); /* * We are guaranteed to have at least one reference to the mark from * either the inode or the caller of fsnotify_destroy_mark(). */ BUG_ON(refcount_read(&entry->refcnt) < 1); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro2856.00%120.00%
Eric Paris1224.00%240.00%
Miklos Szeredi918.00%120.00%
Elena Reshetova12.00%120.00%
Total50100.00%5100.00%

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) { int i; audit_tree_group = fsnotify_alloc_group(&audit_tree_ops); if (IS_ERR(audit_tree_group)) audit_panic("cannot initialize fsnotify group for rectree watches"); for (i = 0; i < HASH_SIZE; i++) INIT_LIST_HEAD(&chunk_hash_heads[i]); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro5291.23%133.33%
Eric Paris58.77%266.67%
Total57100.00%3100.00%

__initcall(audit_tree_init);

Overall Contributors

PersonTokensPropCommitsCommitProp
Al Viro387577.19%1322.03%
Eric Paris4468.88%915.25%
Jan Kara2755.48%1322.03%
Imre Palik1973.92%11.69%
Kees Cook781.55%11.69%
Miklos Szeredi460.92%35.08%
David Howells230.46%23.39%
Richard Guy Briggs190.38%23.39%
Chen Gang S110.22%23.39%
Lino Sanfilippo100.20%11.69%
Jiri Slaby80.16%11.69%
Elena Reshetova80.16%23.39%
Jan Blunck70.14%23.39%
Paul E. McKenney60.12%11.69%
Yaowei Bai30.06%11.69%
Tejun Heo30.06%11.69%
Lai Jiangshan20.04%11.69%
Lucas De Marchi10.02%11.69%
Steve Grubb10.02%11.69%
Greg Kroah-Hartman10.02%11.69%
Total5020100.00%59100.00%
Directory: kernel
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.