projects/linux·blob master · refs

1109 lines · 26.0 KiB

1// SPDX-License-Identifier: GPL-2.0
2#include "audit.h"
3#include <linux/fsnotify_backend.h>
4#include <linux/namei.h>
5#include <linux/mount.h>
6#include <linux/kthread.h>
7#include <linux/refcount.h>
8#include <linux/slab.h>
9
10struct audit_tree;
11struct audit_chunk;
12
13struct audit_tree {
14 refcount_t count;
15 int goner;
16 struct audit_chunk *root;
17 struct list_head chunks;
18 struct list_head rules;
19 struct list_head list;
20 struct list_head same_root;
21 struct rcu_head head;
22 char pathname[];
23};
24
25struct audit_chunk {
26 struct list_head hash;
27 unsigned long key;
28 struct fsnotify_mark *mark;
29 struct list_head trees; /* with root here */
30 int count;
31 atomic_long_t refs;
32 struct rcu_head head;
33 struct audit_node {
34 struct list_head list;
35 struct audit_tree *owner;
36 unsigned int index; /* index; upper bit indicates 'will prune' */
37 } owners[] __counted_by(count);
38};
39
40struct audit_tree_mark {
41 struct fsnotify_mark mark;
42 struct audit_chunk *chunk;
43};
44
45static LIST_HEAD(tree_list);
46static LIST_HEAD(prune_list);
47static struct task_struct *prune_thread;
48
49/*
50 * One struct chunk is attached to each inode of interest through
51 * audit_tree_mark (fsnotify mark). We replace struct chunk on tagging /
52 * untagging, the mark is stable as long as there is chunk attached. The
53 * association between mark and chunk is protected by hash_lock and
54 * audit_tree_group->mark_mutex. Thus as long as we hold
55 * audit_tree_group->mark_mutex and check that the mark is alive by
56 * FSNOTIFY_MARK_FLAG_ATTACHED flag check, we are sure the mark points to
57 * the current chunk.
58 *
59 * Rules have pointer to struct audit_tree.
60 * Rules have struct list_head rlist forming a list of rules over
61 * the same tree.
62 * References to struct chunk are collected at audit_inode{,_child}()
63 * time and used in AUDIT_TREE rule matching.
64 * These references are dropped at the same time we are calling
65 * audit_free_names(), etc.
66 *
67 * Cyclic lists galore:
68 * tree.chunks anchors chunk.owners[].list hash_lock
69 * tree.rules anchors rule.rlist audit_filter_mutex
70 * chunk.trees anchors tree.same_root hash_lock
71 * chunk.hash is a hash with middle bits of watch.inode as
72 * a hash function. RCU, hash_lock
73 *
74 * tree is refcounted; one reference for "some rules on rules_list refer to
75 * it", one for each chunk with pointer to it.
76 *
77 * chunk is refcounted by embedded .refs. Mark associated with the chunk holds
78 * one chunk reference. This reference is dropped either when a mark is going
79 * to be freed (corresponding inode goes away) or when chunk attached to the
80 * mark gets replaced. This reference must be dropped using
81 * audit_mark_put_chunk() to make sure the reference is dropped only after RCU
82 * grace period as it protects RCU readers of the hash table.
83 *
84 * node.index allows to get from node.list to containing chunk.
85 * MSB of that sucker is stolen to mark taggings that we might have to
86 * revert - several operations have very unpleasant cleanup logics and
87 * that makes a difference. Some.
88 */
89
90static struct fsnotify_group *audit_tree_group __ro_after_init;
91static struct kmem_cache *audit_tree_mark_cachep __ro_after_init;
92
93static struct audit_tree *alloc_tree(const char *s)
94{
95 struct audit_tree *tree;
96 size_t sz;
97
98 sz = strlen(s) + 1;
99 tree = kmalloc_flex(*tree, pathname, sz);
100 if (tree) {
101 refcount_set(&tree->count, 1);
102 tree->goner = 0;
103 INIT_LIST_HEAD(&tree->chunks);
104 INIT_LIST_HEAD(&tree->rules);
105 INIT_LIST_HEAD(&tree->list);
106 INIT_LIST_HEAD(&tree->same_root);
107 tree->root = NULL;
108 strscpy(tree->pathname, s, sz);
109 }
110 return tree;
111}
112
113static inline void get_tree(struct audit_tree *tree)
114{
115 refcount_inc(&tree->count);
116}
117
118static inline void put_tree(struct audit_tree *tree)
119{
120 if (refcount_dec_and_test(&tree->count))
121 kfree_rcu(tree, head);
122}
123
124/* to avoid bringing the entire thing in audit.h */
125const char *audit_tree_path(struct audit_tree *tree)
126{
127 return tree->pathname;
128}
129
130static void free_chunk(struct audit_chunk *chunk)
131{
132 int i;
133
134 for (i = 0; i < chunk->count; i++) {
135 if (chunk->owners[i].owner)
136 put_tree(chunk->owners[i].owner);
137 }
138 kfree(chunk);
139}
140
141void audit_put_chunk(struct audit_chunk *chunk)
142{
143 if (atomic_long_dec_and_test(&chunk->refs))
144 free_chunk(chunk);
145}
146
147static void __put_chunk(struct rcu_head *rcu)
148{
149 struct audit_chunk *chunk = container_of(rcu, struct audit_chunk, head);
150 audit_put_chunk(chunk);
151}
152
153/*
154 * Drop reference to the chunk that was held by the mark. This is the reference
155 * that gets dropped after we've removed the chunk from the hash table and we
156 * use it to make sure chunk cannot be freed before RCU grace period expires.
157 */
158static void audit_mark_put_chunk(struct audit_chunk *chunk)
159{
160 call_rcu(&chunk->head, __put_chunk);
161}
162
163static inline struct audit_tree_mark *audit_mark(struct fsnotify_mark *mark)
164{
165 return container_of(mark, struct audit_tree_mark, mark);
166}
167
168static struct audit_chunk *mark_chunk(struct fsnotify_mark *mark)
169{
170 return audit_mark(mark)->chunk;
171}
172
173static void audit_tree_destroy_watch(struct fsnotify_mark *mark)
174{
175 kmem_cache_free(audit_tree_mark_cachep, audit_mark(mark));
176}
177
178static struct fsnotify_mark *alloc_mark(void)
179{
180 struct audit_tree_mark *amark;
181
182 amark = kmem_cache_zalloc(audit_tree_mark_cachep, GFP_KERNEL);
183 if (!amark)
184 return NULL;
185 fsnotify_init_mark(&amark->mark, audit_tree_group);
186 amark->mark.mask = FS_IN_IGNORED;
187 return &amark->mark;
188}
189
190static struct audit_chunk *alloc_chunk(int count)
191{
192 struct audit_chunk *chunk;
193 int i;
194
195 chunk = kzalloc_flex(*chunk, owners, count);
196 if (!chunk)
197 return NULL;
198
199 INIT_LIST_HEAD(&chunk->hash);
200 INIT_LIST_HEAD(&chunk->trees);
201 chunk->count = count;
202 atomic_long_set(&chunk->refs, 1);
203 for (i = 0; i < count; i++) {
204 INIT_LIST_HEAD(&chunk->owners[i].list);
205 chunk->owners[i].index = i;
206 }
207 return chunk;
208}
209
210enum {HASH_SIZE = 128};
211static struct list_head chunk_hash_heads[HASH_SIZE];
212static __cacheline_aligned_in_smp DEFINE_SPINLOCK(hash_lock);
213
214/* Function to return search key in our hash from inode. */
215static unsigned long inode_to_key(const struct inode *inode)
216{
217 /* Use address pointed to by connector->obj as the key */
218 return (unsigned long)&inode->i_fsnotify_marks;
219}
220
221static inline struct list_head *chunk_hash(unsigned long key)
222{
223 unsigned long n = key / L1_CACHE_BYTES;
224 return chunk_hash_heads + n % HASH_SIZE;
225}
226
227/* hash_lock & mark->group->mark_mutex is held by caller */
228static void insert_hash(struct audit_chunk *chunk)
229{
230 struct list_head *list;
231
232 /*
233 * Make sure chunk is fully initialized before making it visible in the
234 * hash. Pairs with a data dependency barrier in READ_ONCE() in
235 * audit_tree_lookup().
236 */
237 smp_wmb();
238 WARN_ON_ONCE(!chunk->key);
239 list = chunk_hash(chunk->key);
240 list_add_rcu(&chunk->hash, list);
241}
242
243/* called under rcu_read_lock */
244struct audit_chunk *audit_tree_lookup(const struct inode *inode)
245{
246 unsigned long key = inode_to_key(inode);
247 struct list_head *list = chunk_hash(key);
248 struct audit_chunk *p;
249
250 list_for_each_entry_rcu(p, list, hash) {
251 /*
252 * We use a data dependency barrier in READ_ONCE() to make sure
253 * the chunk we see is fully initialized.
254 */
255 if (READ_ONCE(p->key) == key) {
256 atomic_long_inc(&p->refs);
257 return p;
258 }
259 }
260 return NULL;
261}
262
263bool audit_tree_match(struct audit_chunk *chunk, struct audit_tree *tree)
264{
265 int n;
266 for (n = 0; n < chunk->count; n++)
267 if (chunk->owners[n].owner == tree)
268 return true;
269 return false;
270}
271
272/* tagging and untagging inodes with trees */
273
274static struct audit_chunk *find_chunk(struct audit_node *p)
275{
276 int index = p->index & ~(1U<<31);
277 p -= index;
278 return container_of(p, struct audit_chunk, owners[0]);
279}
280
281static void replace_mark_chunk(struct fsnotify_mark *mark,
282 struct audit_chunk *chunk)
283{
284 struct audit_chunk *old;
285
286 assert_spin_locked(&hash_lock);
287 old = mark_chunk(mark);
288 audit_mark(mark)->chunk = chunk;
289 if (chunk)
290 chunk->mark = mark;
291 if (old)
292 old->mark = NULL;
293}
294
295static void replace_chunk(struct audit_chunk *new, struct audit_chunk *old)
296{
297 struct audit_tree *owner;
298 int i, j;
299
300 new->key = old->key;
301 list_splice_init(&old->trees, &new->trees);
302 list_for_each_entry(owner, &new->trees, same_root)
303 owner->root = new;
304 for (i = j = 0; j < old->count; i++, j++) {
305 if (!old->owners[j].owner) {
306 i--;
307 continue;
308 }
309 owner = old->owners[j].owner;
310 new->owners[i].owner = owner;
311 new->owners[i].index = old->owners[j].index - j + i;
312 if (!owner) /* result of earlier fallback */
313 continue;
314 get_tree(owner);
315 list_replace_init(&old->owners[j].list, &new->owners[i].list);
316 }
317 replace_mark_chunk(old->mark, new);
318 /*
319 * Make sure chunk is fully initialized before making it visible in the
320 * hash. Pairs with a data dependency barrier in READ_ONCE() in
321 * audit_tree_lookup().
322 */
323 smp_wmb();
324 list_replace_rcu(&old->hash, &new->hash);
325}
326
327static void remove_chunk_node(struct audit_chunk *chunk, struct audit_node *p)
328{
329 struct audit_tree *owner = p->owner;
330
331 if (owner->root == chunk) {
332 list_del_init(&owner->same_root);
333 owner->root = NULL;
334 }
335 list_del_init(&p->list);
336 p->owner = NULL;
337 put_tree(owner);
338}
339
340static int chunk_count_trees(struct audit_chunk *chunk)
341{
342 int i;
343 int ret = 0;
344
345 for (i = 0; i < chunk->count; i++)
346 if (chunk->owners[i].owner)
347 ret++;
348 return ret;
349}
350
351static void untag_chunk(struct audit_chunk *chunk, struct fsnotify_mark *mark)
352{
353 struct audit_chunk *new;
354 int size;
355
356 fsnotify_group_lock(audit_tree_group);
357 /*
358 * mark_mutex stabilizes chunk attached to the mark so we can check
359 * whether it didn't change while we've dropped hash_lock.
360 */
361 if (!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED) ||
362 mark_chunk(mark) != chunk)
363 goto out_mutex;
364
365 size = chunk_count_trees(chunk);
366 if (!size) {
367 spin_lock(&hash_lock);
368 list_del_init(&chunk->trees);
369 list_del_rcu(&chunk->hash);
370 replace_mark_chunk(mark, NULL);
371 spin_unlock(&hash_lock);
372 fsnotify_detach_mark(mark);
373 fsnotify_group_unlock(audit_tree_group);
374 audit_mark_put_chunk(chunk);
375 fsnotify_free_mark(mark);
376 return;
377 }
378
379 new = alloc_chunk(size);
380 if (!new)
381 goto out_mutex;
382
383 spin_lock(&hash_lock);
384 /*
385 * This has to go last when updating chunk as once replace_chunk() is
386 * called, new RCU readers can see the new chunk.
387 */
388 replace_chunk(new, chunk);
389 spin_unlock(&hash_lock);
390 fsnotify_group_unlock(audit_tree_group);
391 audit_mark_put_chunk(chunk);
392 return;
393
394out_mutex:
395 fsnotify_group_unlock(audit_tree_group);
396}
397
398/* Call with group->mark_mutex held, releases it */
399static int create_chunk(struct inode *inode, struct audit_tree *tree)
400{
401 struct fsnotify_mark *mark;
402 struct audit_chunk *chunk = alloc_chunk(1);
403
404 if (!chunk) {
405 fsnotify_group_unlock(audit_tree_group);
406 return -ENOMEM;
407 }
408
409 mark = alloc_mark();
410 if (!mark) {
411 fsnotify_group_unlock(audit_tree_group);
412 kfree(chunk);
413 return -ENOMEM;
414 }
415
416 if (fsnotify_add_inode_mark_locked(mark, inode, 0)) {
417 fsnotify_group_unlock(audit_tree_group);
418 fsnotify_put_mark(mark);
419 kfree(chunk);
420 return -ENOSPC;
421 }
422
423 spin_lock(&hash_lock);
424 if (tree->goner) {
425 spin_unlock(&hash_lock);
426 fsnotify_detach_mark(mark);
427 fsnotify_group_unlock(audit_tree_group);
428 fsnotify_free_mark(mark);
429 fsnotify_put_mark(mark);
430 kfree(chunk);
431 return 0;
432 }
433 replace_mark_chunk(mark, chunk);
434 chunk->owners[0].index = (1U << 31);
435 chunk->owners[0].owner = tree;
436 get_tree(tree);
437 list_add(&chunk->owners[0].list, &tree->chunks);
438 if (!tree->root) {
439 tree->root = chunk;
440 list_add(&tree->same_root, &chunk->trees);
441 }
442 chunk->key = inode_to_key(inode);
443 /*
444 * Inserting into the hash table has to go last as once we do that RCU
445 * readers can see the chunk.
446 */
447 insert_hash(chunk);
448 spin_unlock(&hash_lock);
449 fsnotify_group_unlock(audit_tree_group);
450 /*
451 * Drop our initial reference. When mark we point to is getting freed,
452 * we get notification through ->freeing_mark callback and cleanup
453 * chunk pointing to this mark.
454 */
455 fsnotify_put_mark(mark);
456 return 0;
457}
458
459/* the first tagged inode becomes root of tree */
460static int tag_chunk(struct inode *inode, struct audit_tree *tree)
461{
462 struct fsnotify_mark *mark;
463 struct audit_chunk *chunk, *old;
464 struct audit_node *p;
465 int n;
466
467 fsnotify_group_lock(audit_tree_group);
468 mark = fsnotify_find_inode_mark(inode, audit_tree_group);
469 if (!mark)
470 return create_chunk(inode, tree);
471
472 /*
473 * Found mark is guaranteed to be attached and mark_mutex protects mark
474 * from getting detached and thus it makes sure there is chunk attached
475 * to the mark.
476 */
477 /* are we already there? */
478 spin_lock(&hash_lock);
479 old = mark_chunk(mark);
480 for (n = 0; n < old->count; n++) {
481 if (old->owners[n].owner == tree) {
482 spin_unlock(&hash_lock);
483 fsnotify_group_unlock(audit_tree_group);
484 fsnotify_put_mark(mark);
485 return 0;
486 }
487 }
488 spin_unlock(&hash_lock);
489
490 chunk = alloc_chunk(old->count + 1);
491 if (!chunk) {
492 fsnotify_group_unlock(audit_tree_group);
493 fsnotify_put_mark(mark);
494 return -ENOMEM;
495 }
496
497 spin_lock(&hash_lock);
498 if (tree->goner) {
499 spin_unlock(&hash_lock);
500 fsnotify_group_unlock(audit_tree_group);
501 fsnotify_put_mark(mark);
502 kfree(chunk);
503 return 0;
504 }
505 p = &chunk->owners[chunk->count - 1];
506 p->index = (chunk->count - 1) | (1U<<31);
507 p->owner = tree;
508 get_tree(tree);
509 list_add(&p->list, &tree->chunks);
510 if (!tree->root) {
511 tree->root = chunk;
512 list_add(&tree->same_root, &chunk->trees);
513 }
514 /*
515 * This has to go last when updating chunk as once replace_chunk() is
516 * called, new RCU readers can see the new chunk.
517 */
518 replace_chunk(chunk, old);
519 spin_unlock(&hash_lock);
520 fsnotify_group_unlock(audit_tree_group);
521 fsnotify_put_mark(mark); /* pair to fsnotify_find_mark */
522 audit_mark_put_chunk(old);
523
524 return 0;
525}
526
527static void audit_tree_log_remove_rule(struct audit_context *context,
528 struct audit_krule *rule)
529{
530 struct audit_buffer *ab;
531
532 if (!audit_enabled)
533 return;
534 ab = audit_log_start(context, GFP_KERNEL, AUDIT_CONFIG_CHANGE);
535 if (unlikely(!ab))
536 return;
537 audit_log_format(ab, "op=remove_rule dir=");
538 audit_log_untrustedstring(ab, rule->tree->pathname);
539 audit_log_key(ab, rule->filterkey);
540 audit_log_format(ab, " list=%d res=1", rule->listnr);
541 audit_log_end(ab);
542}
543
544static void kill_rules(struct audit_context *context, struct audit_tree *tree)
545{
546 struct audit_krule *rule, *next;
547 struct audit_entry *entry;
548 bool need_sync = false;
549
550 list_for_each_entry_safe(rule, next, &tree->rules, rlist) {
551 entry = container_of(rule, struct audit_entry, rule);
552
553 if (rule->tree) {
554 /* not a half-baked one */
555 audit_tree_log_remove_rule(context, rule);
556 rule->tree = NULL;
557 list_del_rcu(&entry->list);
558 list_del(&entry->rule.list);
559 if (entry->rule.exe)
560 need_sync = true;
561 } else {
562 list_del_init(&rule->rlist);
563 }
564 }
565
566 if (list_empty(&tree->rules))
567 return;
568
569 if (need_sync)
570 synchronize_rcu();
571
572 list_for_each_entry_safe(rule, next, &tree->rules, rlist) {
573 entry = container_of(rule, struct audit_entry, rule);
574
575 list_del_init(&rule->rlist);
576 if (entry->rule.exe)
577 audit_remove_mark(entry->rule.exe);
578 call_rcu(&entry->rcu, audit_free_rule_rcu);
579 }
580}
581
582/*
583 * Remove tree from chunks. If 'tagged' is set, remove tree only from tagged
584 * chunks. The function expects tagged chunks are all at the beginning of the
585 * chunks list.
586 */
587static void prune_tree_chunks(struct audit_tree *victim, bool tagged)
588{
589 spin_lock(&hash_lock);
590 while (!list_empty(&victim->chunks)) {
591 struct audit_node *p;
592 struct audit_chunk *chunk;
593 struct fsnotify_mark *mark;
594
595 p = list_first_entry(&victim->chunks, struct audit_node, list);
596 /* have we run out of marked? */
597 if (tagged && !(p->index & (1U<<31)))
598 break;
599 chunk = find_chunk(p);
600 mark = chunk->mark;
601 remove_chunk_node(chunk, p);
602 /* Racing with audit_tree_freeing_mark()? */
603 if (!mark)
604 continue;
605 fsnotify_get_mark(mark);
606 spin_unlock(&hash_lock);
607
608 untag_chunk(chunk, mark);
609 fsnotify_put_mark(mark);
610
611 spin_lock(&hash_lock);
612 }
613 spin_unlock(&hash_lock);
614}
615
616/*
617 * finish killing struct audit_tree
618 */
619static void prune_one(struct audit_tree *victim)
620{
621 prune_tree_chunks(victim, false);
622 put_tree(victim);
623}
624
625/* trim the uncommitted chunks from tree */
626
627static void trim_marked(struct audit_tree *tree)
628{
629 struct list_head *p, *q;
630 spin_lock(&hash_lock);
631 if (tree->goner) {
632 spin_unlock(&hash_lock);
633 return;
634 }
635 /* reorder */
636 for (p = tree->chunks.next; p != &tree->chunks; p = q) {
637 struct audit_node *node = list_entry(p, struct audit_node, list);
638 q = p->next;
639 if (node->index & (1U<<31)) {
640 list_del_init(p);
641 list_add(p, &tree->chunks);
642 }
643 }
644 spin_unlock(&hash_lock);
645
646 prune_tree_chunks(tree, true);
647
648 spin_lock(&hash_lock);
649 if (!tree->root && !tree->goner) {
650 tree->goner = 1;
651 spin_unlock(&hash_lock);
652 mutex_lock(&audit_filter_mutex);
653 kill_rules(audit_context(), tree);
654 list_del_init(&tree->list);
655 mutex_unlock(&audit_filter_mutex);
656 prune_one(tree);
657 } else {
658 spin_unlock(&hash_lock);
659 }
660}
661
662static void audit_schedule_prune(void);
663
664/* called with audit_filter_mutex */
665int audit_remove_tree_rule(struct audit_krule *rule)
666{
667 struct audit_tree *tree;
668 tree = rule->tree;
669 if (tree) {
670 spin_lock(&hash_lock);
671 list_del_init(&rule->rlist);
672 if (list_empty(&tree->rules) && !tree->goner) {
673 tree->root = NULL;
674 list_del_init(&tree->same_root);
675 tree->goner = 1;
676 list_move(&tree->list, &prune_list);
677 rule->tree = NULL;
678 spin_unlock(&hash_lock);
679 audit_schedule_prune();
680 return 1;
681 }
682 rule->tree = NULL;
683 spin_unlock(&hash_lock);
684 return 1;
685 }
686 return 0;
687}
688
689void audit_trim_trees(void)
690{
691 struct list_head cursor;
692
693 mutex_lock(&audit_filter_mutex);
694 list_add(&cursor, &tree_list);
695 while (cursor.next != &tree_list) {
696 struct audit_tree *tree;
697 struct path path;
698 struct audit_node *node;
699 const struct path *paths;
700 struct path array[16];
701 int err;
702
703 tree = container_of(cursor.next, struct audit_tree, list);
704 get_tree(tree);
705 list_move(&cursor, &tree->list);
706 mutex_unlock(&audit_filter_mutex);
707
708 err = kern_path(tree->pathname, 0, &path);
709 if (err)
710 goto skip_it;
711
712 paths = collect_paths(&path, array, 16);
713 path_put(&path);
714 if (IS_ERR(paths))
715 goto skip_it;
716
717 spin_lock(&hash_lock);
718 list_for_each_entry(node, &tree->chunks, list) {
719 struct audit_chunk *chunk = find_chunk(node);
720 /* this could be NULL if the watch is dying else where... */
721 node->index |= 1U<<31;
722 for (const struct path *p = paths; p->dentry; p++) {
723 struct inode *inode = p->dentry->d_inode;
724 if (inode_to_key(inode) == chunk->key) {
725 node->index &= ~(1U<<31);
726 break;
727 }
728 }
729 }
730 spin_unlock(&hash_lock);
731 trim_marked(tree);
732 drop_collected_paths(paths, array);
733skip_it:
734 put_tree(tree);
735 mutex_lock(&audit_filter_mutex);
736 }
737 list_del(&cursor);
738 mutex_unlock(&audit_filter_mutex);
739}
740
741int audit_make_tree(struct audit_krule *rule, char *pathname, u32 op)
742{
743
744 if (pathname[0] != '/' ||
745 (rule->listnr != AUDIT_FILTER_EXIT &&
746 rule->listnr != AUDIT_FILTER_URING_EXIT) ||
747 op != Audit_equal ||
748 rule->inode_f || rule->watch || rule->tree)
749 return -EINVAL;
750 rule->tree = alloc_tree(pathname);
751 if (!rule->tree)
752 return -ENOMEM;
753 return 0;
754}
755
756void audit_put_tree(struct audit_tree *tree)
757{
758 put_tree(tree);
759}
760
761static int tag_mounts(const struct path *paths, struct audit_tree *tree)
762{
763 for (const struct path *p = paths; p->dentry; p++) {
764 int err = tag_chunk(p->dentry->d_inode, tree);
765 if (err)
766 return err;
767 }
768 return 0;
769}
770
771/*
772 * That gets run when evict_chunk() ends up needing to kill audit_tree.
773 * Runs from a separate thread.
774 */
775static int prune_tree_thread(void *unused)
776{
777 for (;;) {
778 if (list_empty(&prune_list)) {
779 set_current_state(TASK_INTERRUPTIBLE);
780 schedule();
781 }
782
783 audit_ctl_lock();
784 mutex_lock(&audit_filter_mutex);
785
786 while (!list_empty(&prune_list)) {
787 struct audit_tree *victim;
788
789 victim = list_entry(prune_list.next,
790 struct audit_tree, list);
791 list_del_init(&victim->list);
792
793 mutex_unlock(&audit_filter_mutex);
794
795 prune_one(victim);
796
797 mutex_lock(&audit_filter_mutex);
798 }
799
800 mutex_unlock(&audit_filter_mutex);
801 audit_ctl_unlock();
802 }
803 return 0;
804}
805
806static int audit_launch_prune(void)
807{
808 if (prune_thread)
809 return 0;
810 prune_thread = kthread_run(prune_tree_thread, NULL,
811 "audit_prune_tree");
812 if (IS_ERR(prune_thread)) {
813 pr_err("cannot start thread audit_prune_tree");
814 prune_thread = NULL;
815 return -ENOMEM;
816 }
817 return 0;
818}
819
820/* called with audit_filter_mutex */
821int audit_add_tree_rule(struct audit_krule *rule)
822{
823 struct audit_tree *seed = rule->tree, *tree;
824 struct path path;
825 struct path array[16];
826 const struct path *paths;
827 int err;
828
829 rule->tree = NULL;
830 list_for_each_entry(tree, &tree_list, list) {
831 if (!strcmp(seed->pathname, tree->pathname)) {
832 put_tree(seed);
833 rule->tree = tree;
834 list_add(&rule->rlist, &tree->rules);
835 return 0;
836 }
837 }
838 tree = seed;
839 list_add(&tree->list, &tree_list);
840 list_add(&rule->rlist, &tree->rules);
841 /* do not set rule->tree yet */
842 mutex_unlock(&audit_filter_mutex);
843
844 if (unlikely(!prune_thread)) {
845 err = audit_launch_prune();
846 if (err)
847 goto Err;
848 }
849
850 err = kern_path(tree->pathname, 0, &path);
851 if (err)
852 goto Err;
853 paths = collect_paths(&path, array, 16);
854 path_put(&path);
855 if (IS_ERR(paths)) {
856 err = PTR_ERR(paths);
857 goto Err;
858 }
859
860 get_tree(tree);
861 err = tag_mounts(paths, tree);
862 drop_collected_paths(paths, array);
863
864 if (!err) {
865 struct audit_node *node;
866 spin_lock(&hash_lock);
867 list_for_each_entry(node, &tree->chunks, list)
868 node->index &= ~(1U<<31);
869 spin_unlock(&hash_lock);
870 } else {
871 trim_marked(tree);
872 goto Err;
873 }
874
875 mutex_lock(&audit_filter_mutex);
876 if (list_empty(&rule->rlist)) {
877 put_tree(tree);
878 return -ENOENT;
879 }
880 rule->tree = tree;
881 put_tree(tree);
882
883 return 0;
884Err:
885 mutex_lock(&audit_filter_mutex);
886 list_del_init(&tree->list);
887 list_del_init(&tree->rules);
888 put_tree(tree);
889 return err;
890}
891
892int audit_tag_tree(char *old, char *new)
893{
894 struct list_head cursor, barrier;
895 int failed = 0;
896 struct path path1, path2;
897 struct path array[16];
898 const struct path *paths;
899 int err;
900
901 err = kern_path(new, 0, &path2);
902 if (err)
903 return err;
904 paths = collect_paths(&path2, array, 16);
905 path_put(&path2);
906 if (IS_ERR(paths))
907 return PTR_ERR(paths);
908
909 err = kern_path(old, 0, &path1);
910 if (err) {
911 drop_collected_paths(paths, array);
912 return err;
913 }
914
915 mutex_lock(&audit_filter_mutex);
916 list_add(&barrier, &tree_list);
917 list_add(&cursor, &barrier);
918
919 while (cursor.next != &tree_list) {
920 struct audit_tree *tree;
921 int good_one = 0;
922
923 tree = container_of(cursor.next, struct audit_tree, list);
924 get_tree(tree);
925 list_move(&cursor, &tree->list);
926 mutex_unlock(&audit_filter_mutex);
927
928 err = kern_path(tree->pathname, 0, &path2);
929 if (!err) {
930 good_one = path_is_under(&path1, &path2);
931 path_put(&path2);
932 }
933
934 if (!good_one) {
935 put_tree(tree);
936 mutex_lock(&audit_filter_mutex);
937 continue;
938 }
939
940 failed = tag_mounts(paths, tree);
941 if (failed) {
942 put_tree(tree);
943 mutex_lock(&audit_filter_mutex);
944 break;
945 }
946
947 mutex_lock(&audit_filter_mutex);
948 spin_lock(&hash_lock);
949 if (!tree->goner) {
950 list_move(&tree->list, &tree_list);
951 }
952 spin_unlock(&hash_lock);
953 put_tree(tree);
954 }
955
956 while (barrier.prev != &tree_list) {
957 struct audit_tree *tree;
958
959 tree = container_of(barrier.prev, struct audit_tree, list);
960 get_tree(tree);
961 list_move(&tree->list, &barrier);
962 mutex_unlock(&audit_filter_mutex);
963
964 if (!failed) {
965 struct audit_node *node;
966 spin_lock(&hash_lock);
967 list_for_each_entry(node, &tree->chunks, list)
968 node->index &= ~(1U<<31);
969 spin_unlock(&hash_lock);
970 } else {
971 trim_marked(tree);
972 }
973
974 put_tree(tree);
975 mutex_lock(&audit_filter_mutex);
976 }
977 list_del(&barrier);
978 list_del(&cursor);
979 mutex_unlock(&audit_filter_mutex);
980 path_put(&path1);
981 drop_collected_paths(paths, array);
982 return failed;
983}
984
985
986static void audit_schedule_prune(void)
987{
988 wake_up_process(prune_thread);
989}
990
991/*
992 * ... and that one is done if evict_chunk() decides to delay until the end
993 * of syscall. Runs synchronously.
994 */
995void audit_kill_trees(struct audit_context *context)
996{
997 struct list_head *list = &context->killed_trees;
998
999 audit_ctl_lock();
1000 mutex_lock(&audit_filter_mutex);
1001
1002 while (!list_empty(list)) {
1003 struct audit_tree *victim;
1004
1005 victim = list_entry(list->next, struct audit_tree, list);
1006 kill_rules(context, victim);
1007 list_del_init(&victim->list);
1008
1009 mutex_unlock(&audit_filter_mutex);
1010
1011 prune_one(victim);
1012
1013 mutex_lock(&audit_filter_mutex);
1014 }
1015
1016 mutex_unlock(&audit_filter_mutex);
1017 audit_ctl_unlock();
1018}
1019
1020/*
1021 * Here comes the stuff asynchronous to auditctl operations
1022 */
1023
1024static void evict_chunk(struct audit_chunk *chunk)
1025{
1026 struct audit_tree *owner;
1027 struct list_head *postponed = audit_killed_trees();
1028 int need_prune = 0;
1029 int n;
1030
1031 mutex_lock(&audit_filter_mutex);
1032 spin_lock(&hash_lock);
1033 while (!list_empty(&chunk->trees)) {
1034 owner = list_entry(chunk->trees.next,
1035 struct audit_tree, same_root);
1036 owner->goner = 1;
1037 owner->root = NULL;
1038 list_del_init(&owner->same_root);
1039 spin_unlock(&hash_lock);
1040 if (!postponed) {
1041 kill_rules(audit_context(), owner);
1042 list_move(&owner->list, &prune_list);
1043 need_prune = 1;
1044 } else {
1045 list_move(&owner->list, postponed);
1046 }
1047 spin_lock(&hash_lock);
1048 }
1049 list_del_rcu(&chunk->hash);
1050 for (n = 0; n < chunk->count; n++)
1051 list_del_init(&chunk->owners[n].list);
1052 spin_unlock(&hash_lock);
1053 mutex_unlock(&audit_filter_mutex);
1054 if (need_prune)
1055 audit_schedule_prune();
1056}
1057
1058static int audit_tree_handle_event(struct fsnotify_mark *mark, u32 mask,
1059 struct inode *inode, struct inode *dir,
1060 const struct qstr *file_name, u32 cookie)
1061{
1062 return 0;
1063}
1064
1065static void audit_tree_freeing_mark(struct fsnotify_mark *mark,
1066 struct fsnotify_group *group)
1067{
1068 struct audit_chunk *chunk;
1069
1070 fsnotify_group_lock(mark->group);
1071 spin_lock(&hash_lock);
1072 chunk = mark_chunk(mark);
1073 replace_mark_chunk(mark, NULL);
1074 spin_unlock(&hash_lock);
1075 fsnotify_group_unlock(mark->group);
1076 if (chunk) {
1077 evict_chunk(chunk);
1078 audit_mark_put_chunk(chunk);
1079 }
1080
1081 /*
1082 * We are guaranteed to have at least one reference to the mark from
1083 * either the inode or the caller of fsnotify_destroy_mark().
1084 */
1085 BUG_ON(refcount_read(&mark->refcnt) < 1);
1086}
1087
1088static const struct fsnotify_ops audit_tree_ops = {
1089 .handle_inode_event = audit_tree_handle_event,
1090 .freeing_mark = audit_tree_freeing_mark,
1091 .free_mark = audit_tree_destroy_watch,
1092};
1093
1094static int __init audit_tree_init(void)
1095{
1096 int i;
1097
1098 audit_tree_mark_cachep = KMEM_CACHE(audit_tree_mark, SLAB_PANIC);
1099
1100 audit_tree_group = fsnotify_alloc_group(&audit_tree_ops, 0);
1101 if (IS_ERR(audit_tree_group))
1102 audit_panic("cannot initialize fsnotify group for rectree watches");
1103
1104 for (i = 0; i < HASH_SIZE; i++)
1105 INIT_LIST_HEAD(&chunk_hash_heads[i]);
1106
1107 return 0;
1108}
1109__initcall(audit_tree_init);