audit_tree.c 22.6 KB
Newer Older
1
#include "audit.h"
2
#include <linux/fsnotify_backend.h>
3 4
#include <linux/namei.h>
#include <linux/mount.h>
5
#include <linux/kthread.h>
6
#include <linux/slab.h>
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

struct audit_tree;
struct audit_chunk;

struct audit_tree {
	atomic_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;
25
	struct fsnotify_mark mark;
26 27 28
	struct list_head trees;		/* with root here */
	int dead;
	int count;
29
	atomic_long_t refs;
30 31 32 33 34 35 36 37 38 39
	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);
40
static struct task_struct *prune_thread;
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

/*
 * 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.
 *
63
 * chunk is refcounted by embedded fsnotify_mark + .refs (non-zero refcount
64
 * of watch contributes 1 to .refs).
65 66 67 68 69 70 71
 *
 * 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.
 */

72
static struct fsnotify_group *audit_tree_group;
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99

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) {
		atomic_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)
{
	atomic_inc(&tree->count);
}

static inline void put_tree(struct audit_tree *tree)
{
	if (atomic_dec_and_test(&tree->count))
100
		kfree_rcu(tree, head);
101 102 103 104 105 106 107 108
}

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

109
static void free_chunk(struct audit_chunk *chunk)
110 111 112 113 114 115 116 117 118 119
{
	int i;

	for (i = 0; i < chunk->count; i++) {
		if (chunk->owners[i].owner)
			put_tree(chunk->owners[i].owner);
	}
	kfree(chunk);
}

120
void audit_put_chunk(struct audit_chunk *chunk)
121
{
122 123
	if (atomic_long_dec_and_test(&chunk->refs))
		free_chunk(chunk);
124 125
}

126
static void __put_chunk(struct rcu_head *rcu)
127
{
128 129
	struct audit_chunk *chunk = container_of(rcu, struct audit_chunk, head);
	audit_put_chunk(chunk);
130 131
}

132
static void audit_tree_destroy_watch(struct fsnotify_mark *entry)
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
{
	struct audit_chunk *chunk = container_of(entry, struct audit_chunk, mark);
	call_rcu(&chunk->head, __put_chunk);
}

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_destroy_watch);
158
	chunk->mark.mask = FS_IN_IGNORED;
159 160 161
	return chunk;
}

162 163 164 165 166 167 168 169 170 171
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)
{
	unsigned long n = (unsigned long)inode / L1_CACHE_BYTES;
	return chunk_hash_heads + n % HASH_SIZE;
}

172
/* hash_lock & entry->lock is held by caller */
173 174
static void insert_hash(struct audit_chunk *chunk)
{
175
	struct fsnotify_mark *entry = &chunk->mark;
176 177
	struct list_head *list;

178
	if (!entry->inode)
179
		return;
180
	list = chunk_hash(entry->inode);
181 182 183 184 185 186 187
	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);
188
	struct audit_chunk *p;
189

190
	list_for_each_entry_rcu(p, list, hash) {
191
		/* mark.inode may have gone NULL, but who cares? */
192
		if (p->mark.inode == inode) {
193
			atomic_long_inc(&p->refs);
194 195 196 197 198 199
			return p;
		}
	}
	return NULL;
}

200
bool audit_tree_match(struct audit_chunk *chunk, struct audit_tree *tree)
201 202 203 204
{
	int n;
	for (n = 0; n < chunk->count; n++)
		if (chunk->owners[n].owner == tree)
205 206
			return true;
	return false;
207 208 209 210
}

/* tagging and untagging inodes with trees */

211 212 213 214 215 216 217 218
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]);
}

static void untag_chunk(struct node *p)
219
{
220
	struct audit_chunk *chunk = find_chunk(p);
221
	struct fsnotify_mark *entry = &chunk->mark;
222
	struct audit_chunk *new = NULL;
223 224 225 226
	struct audit_tree *owner;
	int size = chunk->count - 1;
	int i, j;

227
	fsnotify_get_mark(entry);
228 229 230

	spin_unlock(&hash_lock);

231 232 233
	if (size)
		new = alloc_chunk(size);

234
	spin_lock(&entry->lock);
235
	if (chunk->dead || !entry->inode) {
236
		spin_unlock(&entry->lock);
237 238
		if (new)
			free_chunk(new);
239
		goto out;
240 241 242 243 244 245 246 247 248 249 250 251 252
	}

	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);
253
		spin_unlock(&entry->lock);
254
		fsnotify_destroy_mark(entry, audit_tree_group);
255
		goto out;
256 257 258 259
	}

	if (!new)
		goto Fallback;
260

261
	fsnotify_duplicate_mark(&new->mark, entry);
262
	if (fsnotify_add_mark(&new->mark, new->mark.group, new->mark.inode, NULL, 1)) {
263
		fsnotify_put_mark(&new->mark);
264 265 266 267 268 269 270 271 272 273 274
		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;
	}

275
	for (i = j = 0; j <= size; i++, j++) {
276 277 278 279 280 281 282 283 284 285 286 287
		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);
288
		list_replace_init(&chunk->owners[j].list, &new->owners[i].list);
289 290 291 292 293 294
	}

	list_replace_rcu(&chunk->hash, &new->hash);
	list_for_each_entry(owner, &new->trees, same_root)
		owner->root = new;
	spin_unlock(&hash_lock);
295
	spin_unlock(&entry->lock);
296
	fsnotify_destroy_mark(entry, audit_tree_group);
297
	fsnotify_put_mark(&new->mark);	/* drop initial reference */
298
	goto out;
299 300 301 302 303 304 305 306 307 308 309 310

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);
311
	spin_unlock(&entry->lock);
312
out:
313
	fsnotify_put_mark(entry);
314
	spin_lock(&hash_lock);
315 316 317 318
}

static int create_chunk(struct inode *inode, struct audit_tree *tree)
{
319
	struct fsnotify_mark *entry;
320 321 322 323
	struct audit_chunk *chunk = alloc_chunk(1);
	if (!chunk)
		return -ENOMEM;

324
	entry = &chunk->mark;
325
	if (fsnotify_add_mark(entry, audit_tree_group, inode, NULL, 0)) {
326
		fsnotify_put_mark(entry);
327 328 329
		return -ENOSPC;
	}

330
	spin_lock(&entry->lock);
331 332 333 334
	spin_lock(&hash_lock);
	if (tree->goner) {
		spin_unlock(&hash_lock);
		chunk->dead = 1;
335
		spin_unlock(&entry->lock);
336
		fsnotify_destroy_mark(entry, audit_tree_group);
337
		fsnotify_put_mark(entry);
338 339 340 341 342 343 344 345 346 347 348 349
		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);
350
	spin_unlock(&entry->lock);
351
	fsnotify_put_mark(entry);	/* drop initial reference */
352 353 354 355 356 357
	return 0;
}

/* the first tagged inode becomes root of tree */
static int tag_chunk(struct inode *inode, struct audit_tree *tree)
{
358
	struct fsnotify_mark *old_entry, *chunk_entry;
359 360 361 362 363
	struct audit_tree *owner;
	struct audit_chunk *chunk, *old;
	struct node *p;
	int n;

364
	old_entry = fsnotify_find_inode_mark(audit_tree_group, inode);
365
	if (!old_entry)
366 367
		return create_chunk(inode, tree);

368
	old = container_of(old_entry, struct audit_chunk, mark);
369 370 371 372 373 374

	/* 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);
375
			fsnotify_put_mark(old_entry);
376 377 378 379 380 381
			return 0;
		}
	}
	spin_unlock(&hash_lock);

	chunk = alloc_chunk(old->count + 1);
382
	if (!chunk) {
383
		fsnotify_put_mark(old_entry);
384
		return -ENOMEM;
385
	}
386

387 388 389
	chunk_entry = &chunk->mark;

	spin_lock(&old_entry->lock);
390
	if (!old_entry->inode) {
391 392 393
		/* old_entry is being shot, lets just lie */
		spin_unlock(&old_entry->lock);
		fsnotify_put_mark(old_entry);
394
		free_chunk(chunk);
395 396 397 398
		return -ENOENT;
	}

	fsnotify_duplicate_mark(chunk_entry, old_entry);
399
	if (fsnotify_add_mark(chunk_entry, chunk_entry->group, chunk_entry->inode, NULL, 1)) {
400
		spin_unlock(&old_entry->lock);
401
		fsnotify_put_mark(chunk_entry);
402
		fsnotify_put_mark(old_entry);
403 404
		return -ENOSPC;
	}
405 406 407

	/* 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);
408
	spin_lock(&hash_lock);
409 410

	/* we now hold old_entry->lock, chunk_entry->lock, and hash_lock */
411 412 413
	if (tree->goner) {
		spin_unlock(&hash_lock);
		chunk->dead = 1;
414 415 416
		spin_unlock(&chunk_entry->lock);
		spin_unlock(&old_entry->lock);

417
		fsnotify_destroy_mark(chunk_entry, audit_tree_group);
418 419 420

		fsnotify_put_mark(chunk_entry);
		fsnotify_put_mark(old_entry);
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
		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);
446 447
	spin_unlock(&chunk_entry->lock);
	spin_unlock(&old_entry->lock);
448
	fsnotify_destroy_mark(old_entry, audit_tree_group);
449
	fsnotify_put_mark(chunk_entry);	/* drop initial reference */
450
	fsnotify_put_mark(old_entry); /* pair to fsnotify_find mark_entry */
451 452 453
	return 0;
}

454
static void audit_tree_log_remove_rule(struct audit_krule *rule)
455 456 457 458 459 460 461
{
	struct audit_buffer *ab;

	ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE);
	if (unlikely(!ab))
		return;
	audit_log_format(ab, "op=");
462
	audit_log_string(ab, "remove_rule");
463 464 465 466 467 468 469
	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);
}

470 471 472 473 474 475 476 477 478 479 480
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 */
481
			audit_tree_log_remove_rule(rule);
482 483
			if (entry->rule.exe)
				audit_remove_mark(entry->rule.exe);
484 485
			rule->tree = NULL;
			list_del_rcu(&entry->list);
Al Viro's avatar
Al Viro committed
486
			list_del(&entry->rule.list);
487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
			call_rcu(&entry->rcu, audit_free_rule_rcu);
		}
	}
}

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

503
		untag_chunk(p);
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537
	}
	spin_unlock(&hash_lock);
	put_tree(victim);
}

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

538
		untag_chunk(node);
539 540 541 542 543 544 545 546 547 548 549 550 551 552
	}
	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);
	}
}

553 554
static void audit_schedule_prune(void);

555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579
/* 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;
}

Al Viro's avatar
Al Viro committed
580 581
static int compare_root(struct vfsmount *mnt, void *arg)
{
582
	return d_backing_inode(mnt->mnt_root) == arg;
Al Viro's avatar
Al Viro committed
583 584
}

585 586 587 588 589 590 591 592
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;
593
		struct path path;
594 595 596 597 598 599 600 601 602 603
		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);

604
		err = kern_path(tree->pathname, 0, &path);
605 606 607
		if (err)
			goto skip_it;

608
		root_mnt = collect_mounts(&path);
609
		path_put(&path);
610
		if (IS_ERR(root_mnt))
611 612 613 614
			goto skip_it;

		spin_lock(&hash_lock);
		list_for_each_entry(node, &tree->chunks, list) {
615
			struct audit_chunk *chunk = find_chunk(node);
616
			/* this could be NULL if the watch is dying else where... */
617
			struct inode *inode = chunk->mark.inode;
618
			node->index |= 1U<<31;
Al Viro's avatar
Al Viro committed
619 620
			if (iterate_mounts(compare_root, inode, root_mnt))
				node->index &= ~(1U<<31);
621 622 623 624 625
		}
		spin_unlock(&hash_lock);
		trim_marked(tree);
		drop_collected_mounts(root_mnt);
skip_it:
626
		put_tree(tree);
627 628 629 630 631 632 633 634 635 636 637
		mutex_lock(&audit_filter_mutex);
	}
	list_del(&cursor);
	mutex_unlock(&audit_filter_mutex);
}

int audit_make_tree(struct audit_krule *rule, char *pathname, u32 op)
{

	if (pathname[0] != '/' ||
	    rule->listnr != AUDIT_FILTER_EXIT ||
638
	    op != Audit_equal ||
639 640 641 642 643 644 645 646 647 648 649 650 651
	    rule->inode_f || rule->watch || rule->tree)
		return -EINVAL;
	rule->tree = alloc_tree(pathname);
	if (!rule->tree)
		return -ENOMEM;
	return 0;
}

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

Al Viro's avatar
Al Viro committed
652 653
static int tag_mount(struct vfsmount *mnt, void *arg)
{
654
	return tag_chunk(d_backing_inode(mnt->mnt_root), arg);
Al Viro's avatar
Al Viro committed
655 656
}

657 658 659 660 661 662 663
/*
 * 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 (;;) {
664 665
		if (list_empty(&prune_list)) {
			set_current_state(TASK_INTERRUPTIBLE);
666
			schedule();
667
		}
668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695

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

static int audit_launch_prune(void)
{
	if (prune_thread)
		return 0;
696
	prune_thread = kthread_run(prune_tree_thread, NULL,
697 698 699 700 701 702
				"audit_prune_tree");
	if (IS_ERR(prune_thread)) {
		pr_err("cannot start thread audit_prune_tree");
		prune_thread = NULL;
		return -ENOMEM;
	}
703
	return 0;
704 705
}

706 707 708 709
/* called with audit_filter_mutex */
int audit_add_tree_rule(struct audit_krule *rule)
{
	struct audit_tree *seed = rule->tree, *tree;
710
	struct path path;
Al Viro's avatar
Al Viro committed
711
	struct vfsmount *mnt;
712 713
	int err;

714
	rule->tree = NULL;
715 716 717 718 719 720 721 722 723 724 725 726 727 728
	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);

729 730 731 732 733 734
	if (unlikely(!prune_thread)) {
		err = audit_launch_prune();
		if (err)
			goto Err;
	}

735
	err = kern_path(tree->pathname, 0, &path);
736 737
	if (err)
		goto Err;
738
	mnt = collect_mounts(&path);
739
	path_put(&path);
740 741
	if (IS_ERR(mnt)) {
		err = PTR_ERR(mnt);
742 743 744 745
		goto Err;
	}

	get_tree(tree);
Al Viro's avatar
Al Viro committed
746
	err = iterate_mounts(tag_mount, tree, mnt);
747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780
	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;
}

int audit_tag_tree(char *old, char *new)
{
	struct list_head cursor, barrier;
	int failed = 0;
781
	struct path path1, path2;
782 783 784
	struct vfsmount *tagged;
	int err;

785
	err = kern_path(new, 0, &path2);
786 787
	if (err)
		return err;
788 789
	tagged = collect_mounts(&path2);
	path_put(&path2);
790 791
	if (IS_ERR(tagged))
		return PTR_ERR(tagged);
792

793
	err = kern_path(old, 0, &path1);
794 795 796 797 798 799 800 801 802 803 804
	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;
805
		int good_one = 0;
806 807 808 809 810 811 812

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

813 814 815 816
		err = kern_path(tree->pathname, 0, &path2);
		if (!err) {
			good_one = path_is_under(&path1, &path2);
			path_put(&path2);
817 818
		}

819
		if (!good_one) {
820 821 822 823 824
			put_tree(tree);
			mutex_lock(&audit_filter_mutex);
			continue;
		}

Al Viro's avatar
Al Viro committed
825
		failed = iterate_mounts(tag_mount, tree, tagged);
826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866
		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);
867
	path_put(&path1);
868 869 870 871
	drop_collected_mounts(tagged);
	return failed;
}

872 873 874

static void audit_schedule_prune(void)
{
875
	wake_up_process(prune_thread);
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
}

/*
 * ... 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);
903 904 905 906 907 908 909 910 911
}

/*
 *  Here comes the stuff asynchronous to auditctl operations
 */

static void evict_chunk(struct audit_chunk *chunk)
{
	struct audit_tree *owner;
912 913
	struct list_head *postponed = audit_killed_trees();
	int need_prune = 0;
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928
	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);
929 930 931 932 933 934 935
		if (!postponed) {
			kill_rules(owner);
			list_move(&owner->list, &prune_list);
			need_prune = 1;
		} else {
			list_move(&owner->list, postponed);
		}
936 937 938 939 940 941
		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);
942
	mutex_unlock(&audit_filter_mutex);
943 944
	if (need_prune)
		audit_schedule_prune();
945 946
}

947
static int audit_tree_handle_event(struct fsnotify_group *group,
948
				   struct inode *to_tell,
949
				   struct fsnotify_mark *inode_mark,
950 951
				   struct fsnotify_mark *vfsmount_mark,
				   u32 mask, void *data, int data_type,
952
				   const unsigned char *file_name, u32 cookie)
953
{
954
	return 0;
955
}
956

957
static void audit_tree_freeing_mark(struct fsnotify_mark *entry, struct fsnotify_group *group)
958 959 960 961
{
	struct audit_chunk *chunk = container_of(entry, struct audit_chunk, mark);

	evict_chunk(chunk);
962 963 964 965 966 967

	/*
	 * 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(atomic_read(&entry->refcnt) < 1);
968 969
}

970 971 972
static const struct fsnotify_ops audit_tree_ops = {
	.handle_event = audit_tree_handle_event,
	.freeing_mark = audit_tree_freeing_mark,
973 974 975 976 977 978
};

static int __init audit_tree_init(void)
{
	int i;

979
	audit_tree_group = fsnotify_alloc_group(&audit_tree_ops);
980 981
	if (IS_ERR(audit_tree_group))
		audit_panic("cannot initialize fsnotify group for rectree watches");
982 983 984 985 986 987 988

	for (i = 0; i < HASH_SIZE; i++)
		INIT_LIST_HEAD(&chunk_hash_heads[i]);

	return 0;
}
__initcall(audit_tree_init);